Connect your own AI keys
Bring your own provider keys so AI-powered apps run on your account
Some apps call AI models. Rather than bundling model costs into the price, those apps can run on your provider key: you pay your provider directly for what you use, and the app's price stays what the creator set. You type the key once, in a window or panel that Panoply opens, and choose which of your apps may use it.
This is usually called BYOK — bring your own key.
What is live and what is planned
Live. The Key Vault is running. Each purchase of a paid hosted app gets its own Vault token, and it ends if the purchase is refunded. The Vault holds your key for two providers, OpenRouter (chat and music) and Runware (the music fallback), encrypted, never returned to the app or to your browser, and used only inside the Vault. The token itself stays on Panoply's servers too: the app reaches the Vault through its own address, so the page never holds it. A free app has no Vault.
You type a key in Panoply's window, not in the app. When an app asks for a key, it opens a separate window on Panoply's own address. You see the app's name and the account you are signed in with, you type the key there, optionally give it a name ("Work key", up to 50 characters), and Panoply checks it with OpenRouter before it stores anything. The key goes from that window straight to the Vault: it never passes through the app's page, so the app's code cannot read it, copy it or send it anywhere. Type a key only in that window. An app that shows its own field asking for a provider key is breaking Panoply's rules: do not enter it, and report the app.
Live. A key can carry a name you choose. It is shown beside the key's last four characters wherever the key is listed: in your account's Settings, under AI keys, and in the app. The app can see the name (it can already see the last four), so do not put anything private in it. When you replace a key the window shows the stored name; whatever it says when you save is what is kept, so clearing it removes the name. A name Panoply does not accept (more than 50 characters, line breaks, control characters, invisible characters such as a zero width space, or nothing visible at all) is refused as key_name_invalid and nothing is stored. The key itself is never shown to anyone.
Live. A key is stored once, with the list of your apps that may use it. Only the apps on that list can use the key; every other app, and every other buyer's app, is refused. You choose the list when you add the key, and you can change it later from Settings. An app you bought later that uses AI offers a key you already have ("Use Work key …abcd for Travel Atlas?"), and nothing is connected unless you say yes: opening the window and closing it again connects nothing. Entering a key from inside an app that already shares its key with other apps replaces it for all of them, and the window names those apps before you save. A new key replaces the old one only if the provider accepts it.
Live. When your access to an app ends for good (a refund with no other purchase of it, or the app's removal), Panoply ends that app's use of your key, and nothing else: the key and your other apps are untouched. A key left with no apps is deleted at the same moment. Deleting your account removes every key you hold, and Panoply checks afterwards that none are left. Buying the app again before that happens keeps its use of the key.
Retired. Anthropic, OpenAI, Google and Mistral keys are not stored and their calls are not run: the Vault refuses both with the code provider_retired. No buyer key was stored for them when this changed (4 November 2026).
Live. Settings has an AI keys row. Add key opens a form right on the Settings page (an OpenRouter key; Runware keys are added from inside an app). It lists your apps that use AI, all ticked, and you untick any that should not use the key. The key goes from that form straight to the Vault, as it does from an app's window: the Settings page's own server never receives it. Each key is then listed with its name, its last four characters and the apps that use it. Apps changes which apps use it, and unticking the last one asks to remove the key, since a key with no apps does not exist. Remove deletes the key and ends every app's use of it at once. Apps you own as an agent's custodian are not in the list: a key covers the apps bought under your own account.
Panoply does not use your key for its own inference.
For creators: how your app gets a key stored
Your app never handles a key. It asks Panoply to open its window, from a click, and then reads what the Vault reports about the stored key: its id, the last four characters, when it was set and, for OpenRouter, whether OpenRouter still accepts it and what it may still spend. A buyer can use one key for several apps, so the window may offer a key the buyer already has instead of asking for a new one; your app sees the same result either way.
// From a button's click handler: it must run straight from the click, or the browser blocks the window.
connectButton.addEventListener('click', async () => {
try {
const key = await panoplyAI.keys.open('openrouter') // or 'runware'
// { provider: 'openrouter', keyId: '6f1c0e7a-…', last4: 'x9Qa', name: 'Work key', updatedAt: '2026-11-04T10:00:00.000Z', status: 'working', limit: 10, ... }
showConnected(key)
} catch (e) {
if (e.code === 'key_entry_popup_blocked') showHint('Allow pop-ups for this app, then press Connect again.')
else if (e.code === 'key_entry_timeout') showHint('No key was entered. Press Connect to try again.')
}
})
// What your app uses, with the key's id, the last four characters, the name (null when there is none) and when it was set, for your settings screen:
const keys = await panoplyAI.keys.list() // { openrouter: { keyId, last4: 'x9Qa', name: 'Work key', updatedAt, status, limit, limitRemaining } }
// Stop using it. This ends your app's use of the key only: other apps the buyer chose keep it, and the key is deleted if yours was the last.
await panoplyAI.keys.delete('openrouter')
keys.open resolves once the buyer has stored or replaced the provider's key, or chosen a key they already have for your app, with that provider's entry from keys.list(). The keyId tells you which key your app now uses; it is not a secret, and it is the same after a replacement and different after a switch to another key. keys.open never carries a key. It rejects with a code:
| code | meaning |
|---|---|
key_entry_popup_blocked | the browser blocked the window: call keys.open straight from a click |
key_entry_timeout | no key was stored in ten minutes |
key_entry_cancelled | you aborted the signal you passed: keys.open('openrouter', { signal }) |
key_provider_invalid | only openrouter and runware are entered this way |
key_name_invalid | shown in the window, never to your page: the buyer typed a name Panoply does not accept, and nothing was stored |
session_expired, vault_revoked, vault_unavailable | as for every other call: the buyer's session ended, their access ended, or the Vault could not check access |
Your page can read a key's name but can neither set nor change it: the name is typed only in Panoply's window. Treat it as text from the buyer: show it as text, never as HTML.
The window cannot be closed or read by your page, so there is no "window closed" event. If your screen has a Cancel button, abort the signal.
keys.set is gone. panoplyAI.keys.set and panoplyVault.keys.set reject with key_entry_moved and send nothing. An app Worker on an older template that still relays one is refused by the Vault with the same code. Do not build a field that asks for a key: the key would pass through your code, which is what this change exists to end, and apps are reviewed for it.
panoplyVault.keys.list, .delete and .open work the same way as the panoplyAI ones; panoplyVault.run refuses every provider: Anthropic, OpenAI, Google and Mistral with provider_retired, OpenRouter and Runware with vault_provider_ai_only (they are reached only through the AI routes your app's Worker serves under /__panoply/ai/, which record each call's cost). A tool's vault.run refuses them the same way.
A failed call rejects with an error carrying a code. vault_revoked means the buyer's access ended (for example, the purchase was refunded) while the app was open; tell them so rather than retrying. vault_unavailable means the vault could not check access right now (an outage, not a revocation): the call was not made, and trying again later is right. The buyer's sign-in is handled for you: an expired session is renewed in the background and the call retried once, and only if that fails does the call reject with session_expired.
An OpenRouter key is checked with OpenRouter before it is stored. A key OpenRouter does not accept is not stored, and the window says so; if the check could not run, nothing is stored either. Your app sees this only as keys.open not resolving.
The Vault also limits what it forwards:
- It supplies the key itself, so a request carrying its own
keyparameter is refused. - Request bodies are capped at 4 MB.
- The provider has 60 seconds to start answering. A stream that has started can run as long as it needs.
- Calls are accepted only from your app's own pages. A request from another app's page is refused, even though it is on the same
panop.lydomain.
What it costs to run a model
Model prices come from the providers, not from Panoply — we take no cut of your model spend. Rates change often, so here is the current picture rather than a number written into this page:
| Model | Provider | Input | Output |
|---|---|---|---|
| Claude Opus 4.8 | Anthropic | $5 | $25 |
| Claude Sonnet 5 | Anthropic | $2 | $10 |
| Claude Haiku 4.5 | Anthropic | $1 | $5 |
| GPT-5.5 | OpenAI | $5 | $30 |
| GPT-5.4 | OpenAI | $2.50 | $15 |
| GPT-5.1 | OpenAI | $1.25 | $10 |
| Gemini 3.1 Pro | $2 | $12 | |
| Gemini 3 Pro | $2 | $12 | |
| Gemini 3.5 Flash | $1.50 | $9 | |
| Mistral Large | Mistral | $0.70 | $2.10 |
| Mistral Medium | Mistral | $1.50 | $7.50 |
Prices are USD per million tokens. Scores are BenchLM’s raw overall score (may be provisional), not the calibrated site ranking. Prices in USD per million tokens. Scores from BenchLM.ai. Rates updated Nov 21, 2026.
Prices are per million tokens, in USD. Use them to estimate what an app will cost you to run: a chat-style app that sends a few thousand tokens per exchange costs fractions of a cent per message on a cheap model, and meaningfully more on a frontier one.
Choosing a model
If an app lets you pick a model, the trade-off is the usual one — cheaper and faster, or slower and more capable. Start on a cheap model and move up only if the output isn't good enough. The app's listing should say which models it supports.
If you'd rather not
An app that needs a key should say so in its description before you buy. Plenty of apps don't need one at all. See Find an app worth buying.