A token service
Something has to turn "this is my app on a real phone" into a credential that expires. Gate/AI runs App Attest and Play Integrity, mints short-lived tokens, and rotates them.
Securely add AI to your mobile app
Add AI to your app without shipping the key.
Every AI feature needs a provider key, and there is nowhere safe to put one inside an app. Gate/AI gives your app a hostname to call instead: it proves the request came from a real install of your app, then adds the key on the way to OpenAI, Anthropic, or Gemini. No backend to build.
Your app
iOS & Android
Secure Enclave / StrongBox key
App Attest Play Integrity
Gate/AI
myapp.in.gate-ai.net
Device
Verified
Token
DPoP-bound
Budget
142 / 200
Secret
Injected
AI provider
A\
Anthropic
sk-ant-…ab3f
Key never leaves the vault
The problem
Your app is a public download. So is anything inside it.
An API key in the binary isn't hidden, it's just not labelled. Pulling it out takes one command, and once it's out, every request made with it lands on your invoice. This is what that looks like, and what it looks like once the key isn't there to find.
Calling the provider directly
key in the binary$ strings MyApp.ipa | grep -i key OPENAI_API_KEY sk-proj-8f2c…R3kQ https://api.openai.com/v1/chat/completions Authorization: Bearer %@
Anyone with the download can do this in under a minute. Then it's their key, on your bill.
Calling through Gate/AI
nothing to steal$ strings MyApp.ipa | grep -i key (no matches) https://myapp.in.gate-ai.net/v1/chat/completions Authorization: DPoP <short-lived, device-bound>
The provider key lives in Gate/AI's vault. The app only ever holds a token that expires in minutes and works on one device.
How it works
Four things happen to a request. You write code for one of them.
Your lane has one box in it, and it's the same call you'd write against the provider directly. The other three run underneath, on every request, without another line from you.
- 1 Gate/AI
Prove the install
The SDK asks Apple or Google to vouch for the app: right bundle, right signature, unmodified device. Once per install.
- 2 Gate/AI
Get a token
That proof is traded for a short-lived token bound to a key in the phone's secure hardware. It never leaves the device.
- 3 You
Make the call
Your code calls your gate's hostname exactly as it would call the provider. Same paths, same bodies, same responses.
- 4 Gate/AI
Forward with the key
Gate/AI checks the device, token, signature and budget, then forwards the request with your provider key attached.
Swift
let config = try GateAIConfiguration( baseURLString: "https://myapp.in.gate-ai.net", teamIdentifier: "ABCDE12345" ) let client = GateAIClient(configuration: config) let (data, _) = try await client.performProxyRequest( path: "/v1/messages", method: .post, body: requestBody )
Kotlin
val config = GateAIConfiguration( baseUrl = "https://myapp.in.gate-ai.net", packageName = packageName, signingCertSha256 = "AA:BB:CC:…" ) val client = GateAIClient.create(this, config) val response = client.performProxyRequest( path = "/v1/messages", method = HttpMethod.POST, body = requestBody )
What you don't have to build
"Just put a backend in front of it" is a six-week project. This is an afternoon.
Every piece below is something you'd otherwise write, host, and keep running before your feature ships.
A key vault
Your provider keys are stored encrypted and injected into the request on the way out. You can replace a key in the Portal; you can never read it back.
Proof of possession
Tokens are bound to a key in the Secure Enclave or StrongBox with DPoP. A token copied off one device is useless on another.
Rate limiting and budgets
Per-gate ceilings and per-device budgets sit in front of your key, so a leaked build or a scripted client can't run up the bill.
Request logging
Every call is recorded with device, version, model, tokens and cost — never the prompt — so you can see what's happening without adding instrumentation.
Uptime
It's a managed service. No servers, no pager, no 3 a.m. certificate renewal.
In the Portal
One page per gate. The whole path, live.
Each gate shows the pipeline as it runs: which apps are attesting, devices and throughput against their caps, the budget policy, and the provider with its spend. Click any stage to change it.
GamePlan AI Healthy Pro plan
App
GamePlan AI
com.fieldstone.gameplan
GamePlan AI
com.fieldstone.gameplan
Gate
gameplan.in.gate-ai.net
Unique devices · Aug140 of 500
Requests / min41 of 120
Quotas
Requests500 / day · 10k / month Tokens2M / month Tiers pro50k requests, unlimited tokens
12 devices throttled today Provider
A\
Anthropic
sk-ant-…ab3f
Spend · Aug$127.40 Top model · 7dclaude-sonnet-4 82%
Key secured Questions developers ask first
- Can't I just obfuscate the key?
- Obfuscation raises the effort from thirty seconds to thirty minutes. The key still has to be in memory to make the request, and an attacker with a jailbroken phone or a proxy reads it there. The only durable fix is for the key never to be on the device.
- What stops someone from calling Gate/AI instead of the provider?
- Every request needs a token that only a verified install of your app can get, and the token is bound to that device's hardware key. Without both, Gate/AI returns 401. And even with both, per-device budgets cap what any one install can spend.
- Does this add latency?
- A few milliseconds of verification on the first request of a session; after that the token is cached and the proxy adds a single hop. Attestation happens once per install, not per request.
- What about users who bring their own key?
- BYOK moves the problem onto your users: they need a provider account, billing, and a key they have to protect. Gate/AI keeps a single key under your control and lets you decide what each user gets.
Want the mechanics? Why shipping secrets in your app is a terrible idea, Apple's App Attest, Google's Play Integrity, and DPoP go deeper.
Your key stays with us. Your feature ships this week.
Free for 25 devices a month. No card, no sales call.