Bring your own key.

Plooi runs every AI node against your own provider account. You pay the model host directly; Plooi never touches your provider bill. Keys are stored server-side, encrypted with AES-256-GCM and never round-trip back to the browser.

What it means

You sign in to Anthropic, OpenAI, or Google AI Studio, generate a key, and paste it into Plooi once. From then on, when a node runs a model, Plooi forwards the request to the provider using your key. Usage lands on your provider invoice, not ours — no middleman markup, no surcharge baked into the token price.

The trade is straightforward: you bring the key that authenticates with the model. In return you get the actual provider price and a direct billing relationship.

Which providers

Plooi supports three providers today. Connect any combination under Settings → AI Providers.

You can connect one, two, or all three. Plooi will only ever call a provider you have actually configured.

How your key is stored

                         ┌─────────────────────────────────────────┐
  paste key in browser → │   store-api-key  Edge Function (EU)    │
                         │     • derive 16-byte salt + 12-byte nonce
                         │     • HKDF-SHA256(master, salt) → key   │
                         │     • AES-256-GCM(plaintext, key, nonce)│
                         │     • write ciphertext to Postgres      │
                         └─────────────────────────────────────────┘
                                          │
                                          ▼
                              ┌──────────────────────┐
                              │  user_api_keys       │  ← service_role only
                              │  (ciphertext + salt  │
                              │   + nonce + version) │
                              └──────────────────────┘
                                          │
                                          ▼  (safe projection)
                              ┌──────────────────────┐
                              │  user_api_keys_      │  ← your browser reads this
                              │  public view         │     (id, service_name,
                              │                      │      key_hint, key_version)
                              └──────────────────────┘

Concrete details:

• Cipher: AES-256-GCM with a per-row 16-byte salt and a 12-byte nonce. The actual encryption key is derived per-row via HKDF-SHA256 from a master key that lives in Supabase Function secrets — a separate store from Postgres. Compromising the database alone does not yield readable keys.
• Write path: browser → store-api-key edge function → encrypt → write. The plaintext exists for one network hop and is then replaced by ciphertext for the rest of its life.
• Read path for your browser: there isn’t one. The browser reads user_api_keys_public (a Postgres view) which exposes only id, service_name, key_hint (last four chars), and key_version. The ciphertext column is REVOKEd from the authenticated role entirely.
• Decrypt path: when ai-proxy runs a model call, it pulls the ciphertext server-side, decrypts in memory for that single call, sends the request to the provider, and discards the plaintext on response.
• RLS: auth.uid() = user_id enforced on every SELECT, INSERT, UPDATE, DELETE, with a WITH CHECK on every mutation.

What’s redacted, what isn’t

Provider errors are sanitized server-side before they reach your browser. A stray ?key=AIza... in a stack trace, an sk-ant-... echoed back in a 401, or a request URL with a token in the query string gets stripped at the proxy layer — no credential leaks through error reporting, no key fragments in Sentry events.

The plaintext key is never written to:

• Application logs
• Audit logs
• Sentry / error reporting
• Database backups (only the ciphertext is captured)
• Analytics / product telemetry

Switching providers

Swap providers at any time. Paste a new key, or delete an existing one, under Settings → AI Providers. Runs already in flight finish on the original provider — Plooi never re-routes a half-completed call.

Per-action model preferences persist: Claude for strategy nodes, Gemini for image generation, etc. Set once on each node and the choice sticks across re-runs.

When a key is revoked at the provider

Plooi does not silently delete or rotate anything on your behalf. The next run that uses a revoked key surfaces an inline error on the node — the provider’s actual response, sanitized — so you can see what went wrong without digging through logs.

Paste a fresh key into the same slot and the next run picks it up. No separate “reconnect” flow.

Audit trail

Every key save, delete, and validation attempt is written to an audit log. Each entry records:

• The action (store / delete / validate)
• The service_name (anthropic / openai / gemini)
• A timestamp
• The last four characters of the key as a hint (••••a4Q1)

The plaintext is never in the audit log. Support can read your audit entries to help diagnose issues; you can request a copy of your own entries at any time.

Common questions

What if Plooi gets breached — can someone read my key? A database-only breach yields ciphertext, per-row salts and nonces. Decryption needs the master key, which lives outside the database in Supabase Function secrets. Both surfaces would have to fall together. Plooi does not store any plaintext copy of your key anywhere.

Can I see when my key was used? Yes — every model call is logged with timestamp, node, and which provider was hit. Cross-check against the provider’s own usage dashboard if you want belt-and-braces.

What if I forget to revoke a key when I leave Plooi? Deleting your Plooi account removes the encrypted row, but the key still works at the provider until you revoke it there. Plooi has no power to revoke a key on a provider’s system.

Why don’t you just give me free credits? Free credits mean Plooi pays the provider, which means Plooi either subsidises you indefinitely (unsustainable) or applies usage caps and surcharges (annoying). BYOK keeps Community genuinely free, with your real provider pricing and no middleman markup.

Is Plooi a reseller for Anthropic, OpenAI, or Google? No. On Community / alpha, you have a direct billing relationship with the provider. Plooi is a client of their APIs using your key — nothing more. On future paid plans, Plooi will resell under its own account; BYOK is no longer in play there.

What about GDPR / data processing? Your encrypted key, the request payloads you send through nodes, and the responses are processed by Plooi (Supabase EU, Frankfurt) and the provider you selected. Provider DPAs are linked from their cards in Settings → AI Providers. Plooi’s own data handling is described in the Privacy Policy and Data Processing Agreement.