Is It Safe to Use Your Own API Key in a Keyboard App?

Connecting your own AI provider key to a keyboard app raises a fair question: is it actually safe to hand a third-party keyboard that much access? The short answer is that the risk comes almost entirely from one iOS permission — Full Access — and understanding what that permission does and does not do is the key to using BYOK safely.

Why AI keyboards need Full Access

iOS treats third-party keyboards as sandboxed by default: they cannot make network requests, and they have limited access to the system. That sandbox is a good default, but it also blocks anything that needs to reach the internet — including sending your text to an AI provider for a rewrite. To make any AI feature work at all, whether it is QKeyboard's built-in AI or your own BYOK key, iOS requires you to grant the keyboard Full Access. There is no way around this requirement — it is an iOS platform rule, not a choice made by any individual keyboard app.

What Full Access actually allows

Full Access permits a keyboard extension to:

• Make network requests, such as sending text to an AI provider for a rewrite.
• Access iOS features like Keychain, which is needed to store an API key securely.

Full Access does not, by itself, mean the keyboard can:

• Read your passwords or the contents of other apps.
• Access your camera, microphone, or location without separate permissions for those.
• See anything you type outside of the keyboard being active.

In other words, Full Access is what makes network and secure storage possible — what a keyboard actually does with that access depends entirely on how the app is built and what it sends over the network. That is why it matters to only grant Full Access to keyboards from developers you trust, and to check what data a keyboard says it collects. For more on how QKeyboard specifically handles this, see our full breakdown of keyboard privacy and Full Access.

Why storing the key in Keychain matters

With BYOK, your API key is stored in the device Keychain — the same secure, encrypted storage iOS uses for passwords and payment details — rather than being sent to or stored on QKeyboard's own servers. This distinction matters for two reasons:

• No middleman. Your rewrite requests go directly from your device to your chosen AI provider using your key. The keyboard maker never sees the key and never proxies your text through its own servers.
• Device-level protection. Keychain entries are encrypted at rest and tied to your device, so the key is not sitting in a plaintext file that could be read by other apps or extracted from a backup casually.

Good practices when using BYOK

Storing the key securely is only half the picture. A few habits make BYOK meaningfully safer in practice:

1. Set spending limits on the provider's dashboard. Most AI providers let you cap monthly spend or set usage alerts. This limits your exposure if a key is ever misused, regardless of the cause.
2. Rotate keys periodically. Generating a new key every few months and revoking the old one is a low-effort way to reduce the impact of a key that may have been exposed somewhere you did not notice.
3. Use a key scoped to one purpose. If your provider supports naming or scoping keys, create one specifically for QKeyboard rather than reusing a key shared across multiple tools.
4. Only grant Full Access to keyboards you trust. Review the developer, the app's stated privacy practices, and whether the permission request makes sense for what the app does.
5. Remove the key if you stop using the app. Deleting the keyboard removes the key from Keychain, but if you switch providers or stop using BYOK, revoking the key on the provider's side is a clean way to close it out.

The bottom line

BYOK does not introduce a new category of risk so much as it shifts where trust is placed: instead of trusting a keyboard maker's servers with your text, you are trusting your chosen AI provider directly, with your own key stored on your own device. Full Access is required to make any of this work, but what matters is how that access is used — and a keyboard that keeps your key in Keychain and sends requests straight to your provider, without routing through its own servers, is following the safer pattern.