Skip to content
Marriska Docs

BYOK (bring your own key)

BYOK — bring your own key — is the option to point Marriska at your OpenAI / Anthropic / Groq / Gemini account instead of using the keys we’ve billed for. When you do, AI calls don’t count against your Marriska quota; they just charge you directly.

This page is about why the option exists and what it actually changes. For the workflow, see How to use your own OpenAI key.

Why we built it

Section titled “Why we built it”

Three reasons, in order of importance:

1. Heavy users shouldn’t be paying twice

Section titled “1. Heavy users shouldn’t be paying twice”

Test generation, parsing, translation, and visual regression all hit LLM providers. We pay a per-token rate; you pay us a flat tier price. For someone running a thousand AI creations a month, that flat price has to either (a) cover the worst-case bill (so they overpay) or (b) cap usage well below their actual need (so they’re throttled).

BYOK breaks the bind. Heavy users connect their own key, pay the provider directly at provider rates, and stop being budgeted on our side. We don’t lose money; they don’t get throttled. Both win.

2. Faster latency on cold paths

Section titled “2. Faster latency on cold paths”

When the platform key is shared across all users, request bursts queue. With your own key, you get your own rate-limit budget — no one else’s run hits your provider quota.

3. Trust and audit boundary

Section titled “3. Trust and audit boundary”

Some teams need to know which logical entity touched their pages and how the inference was billed. With BYOK, the provider’s logs are your provider’s logs. Marriska is no longer the financial intermediary, and there’s a paper trail you control.

How the routing will work

Section titled “How the routing will work”

Each AI task — translation, parsing, visual comparison — is dispatched through a ProviderRegistry that picks the right client based on configured provider/model. Today that’s the platform-level configuration; once per-user/per-org BYOK ships:

  1. Your encrypted key is stored against your org.
  2. Each AI call checks “does this org have a BYOK key for this provider?” first.
  3. If yes, the call goes through your key. If no, it falls back to the platform key (counts against your quota).

Routing is per-task, so you can BYOK the expensive paths (parsing, visual regression) and let the cheap ones run on platform keys.

Supported providers

Section titled “Supported providers”

Marriska’s provider registry routes to five backends:

ProviderWhat it’s good forNotes
OpenAIAll four tasks (translation, parsing, vision, generation)The default for parsing and visual comparison
AnthropicTranslation, parsing, generationDoesn’t currently work for visual regression — vision API differences
Google GeminiAll four tasksVision-capable models work
GroqTranslation, parsingFast and cheap for non-vision tasks
OllamaAnything you have a local model forLocal-only — useful for self-hosters / privacy

The list a given install actually has depends on which API keys are configured. The Settings → LLM Models panel shows which are green (“ready”) versus grey (“not configured”).

What about price?

Section titled “What about price?”

Provider rates change frequently and we’re not going to quote specific token prices in docs that go stale. The right move is: look at your provider’s current pricing page, multiply by your expected token volume (Marriska sends modest contexts — system prompt + user description, plus screenshots for visual), and compare to your tier’s flat price.

The general shape of the math:

  • Light users (a few tests a week): the platform tier is cheaper than provider rates after API overhead. Stay on the platform key.
  • Medium users (regular CI runs, weekly visual regression): break-even territory. BYOK is mostly about latency and audit, not cost.
  • Heavy users (continuous CI, daily full-suite visual regression): BYOK is unambiguously cheaper. Provider rates beat our flat tier cost once you cross the cap.

What stays on platform keys

Section titled “What stays on platform keys”

Even with BYOK on, a few things keep using platform infrastructure:

  • Test execution itself (Playwright). BYOK is about the LLM calls, not the runner.
  • Storage (Postgres, screenshot blobs).
  • Scheduling and orchestration.
  • Auth, billing, dashboards.

In other words: BYOK changes who pays for the AI inference, not who runs the test or stores the data.

Section titled “Related”