Pay in dollars for what you actually use — no opaque token credits. Oriora picks the best model for each task from our catalogue of supported models, based on the priorities and exclusions you set. No preferences? Leave it on Auto and Oriora chooses for you.
The services
We don't sell AI — we sell a service, and use AI to deliver your result. Four ways to use it, from we-do-it-all to you-wire-it-into-your-own-product. What changes is how much you hand over, not who's reselling what.
In an Oriora app
Managed BYOK — your key, no limits
Connect your own AI vendor keys. No daily cap. Your vendor bills you for the AI directly — you pay only Oriora's flat per-call fees: $0.001 for each service layer the call uses.
Managed AI — we do it for you
Nothing to set up — you ask, Oriora does the work and delivers your result, using AI as the tool. A daily spending cap on your account keeps it predictable. You pay the catalogue price for the model Oriora chose, plus the flat per-call fees ($0.001 per layer). Want no ceiling? Bring your own key.
In your own app, agent, or workflow — Managed API BYOK
Server-side — Oriora runs it inside your product
Wire Oriora's service into your own product: it picks the model, runs the call on your connected key, and returns the result. Your vendor bills you for the AI — you pay only the flat per-call fees ($0.002: platform + routing, no app layer).
Client-side — Oriora recommends, you run it
Ask Oriora which model fits the task; it returns a recommendation and you make the call yourself, on your own key. Oriora never sees the key. $0.001 per recommendation — extra-hard requests return two (which model to run, plus which model to verify it) for $0.002.
Across all four, what changes is how much you hand over — from nothing, to your key, to your whole product — never who's reselling what. We don't resell AI; we use it to deliver your result.
Two optional layers can also apply on any lane — each a flat $0.001, and only when your task actually triggers them:
They're not on every call — each fires automatically only when your task triggers it, and you can switch either off in your account. So you only pay for a layer when it actually fires, and only if you leave it on.
You don't hand-pick a model for every call — Oriora does that for you, choosing the best fit for each task within the vendors and priorities you've set. A few things it handles automatically:
Per-task quality scoring
Models are pre-scored against benchmarks per task category. A coding request never gets routed to a model that underperforms on code.
Transparent pricing, under the hood
No opaque token credits — you see which model actually ran and our catalogue rate for it. Oriora doesn't sell or resell AI; you pay for the work and the orchestration.
Prompt cache pass-through
Where the underlying vendor supports prompt caching, requests are structured so the cache fires on repeated content. When it hits, the AI cost line drops automatically.
Circuit breakers
If a provider rate-limits or goes down, the next best model picks up automatically. No error surface to your app.
Weighted fallback
Configurable fallback chains per task type. Define how aggressively to escalate to premium models when the top tier is unavailable.
Models & vendors
Oriora routes across every major AI vendor, picking the best-fit model for each task. The full, always-current list of supported vendors and models — with live per-1M-token pricing — lives in the catalogue.
Our fee is a flat charge per call — $0.001 for each service layer it uses. On Managed AI, the call runs inside an Oriora app: Oriora runs the AI on its own keys to deliver that app's result, and charges the catalogue price for the model that ran — what we charge you for the AI usage we incur to deliver the service, shown openly per model instead of as opaque credits. We don't sell you AI access; you're paying for the service the app delivers, with our flat layer fee on top. What you pay depends on how the call is made and how it's paid:
| Surface | Payment mode | Effective fee |
|---|---|---|
| Managed API BYOK — server-side | BYOK | $0.002 (2 flat layer fees) |
| Managed API BYOK — client-side | BYOK | $0.001 per recommendation ($0.002 extra-hard, incl. verify) |
| Catalog app | Wallet | catalogue price + $0.003 |
| Catalog app | BYOK | $0.003 (3 flat layer fees) |
Each layer a call touches is a flat $0.001 per call — not a percentage of anything. On Managed AI the published catalogue rate for the model that ran is added on top. You only pay for the layers you use:
Two more layers are optional — each a flat $0.001. They fire automatically only when your task triggers them (not on every call), and you can switch either off from your account:
Say a call runs a model whose catalogue rate is $2.00 / 1M tokens, and it uses 250K tokens. The AI cost for that call is 250K × $2.00/1M = $0.50. On Managed AI you pay that $0.50 — the catalogue price for the model Oriora ran on its own keys to deliver the app's result to you, shown openly so you see what the AI behind your service came to (not AI you bought from us). On BYOK your own vendor billed you for those tokens directly, so the AI cost doesn't enter our charge at all. Either way our own fee is the same flat per-call amount — it doesn't scale with the AI cost:
| Lane | What you pay on this call |
|---|---|
| Managed AI catalog app · wallet | $0.50 + $0.003 = $0.503 Oriora ran the AI: catalogue price + 3 flat layer fees (platform + routing + app) |
| Managed BYOK catalog app · your key | $0.003 flat your vendor bills you for the tokens; Oriora charges 3 flat layer fees (platform + routing + app) |
| Managed API BYOK server-side (c1) | $0.002 flat your vendor bills you for the tokens; Oriora charges 2 flat layer fees (platform + routing, no app — raw API) |
| Managed API BYOK client-side (c2) | $0.001 flat no AI runs through us — you get a model recommendation and execute the call yourself |
On any lane, two optional layers can add a flat $0.001 each when they fire: a verify layer if the task is hard enough to warrant a second-model check, and the rent-the-brainlayer when your task matches Oriora's knowledge base. Each fires only when the task triggers it — nothing fires on an unmatched call — and you can switch either off from your account.
Per-model catalogue rates are on the models page. Your wallet shows total spend; download a full itemized CSV — which model ran, the tokens used, and what we charged — whenever you want the detail.
Buy dollars to spend inside the Oriora ecosystem. The price includes processing costs; your local VAT (if any) is added at checkout. You receive the full dollar amount as spendable balance.
| You get | Web (Creem) | In the app (Apple) |
|---|---|---|
| $20 of spending | $21.60 | $28.90 |
| $30 of spending | $32.20 | $42.90 |
| $50 of spending | $53.40 | $71.90 |
| $80 of spending | $85.20 | $114.99 |
| $100 of spending | $106.40 | $142.99 |
| $150 of spending | $159.40 | $214.99 |
| $200 of spending | $212.40 | $289.00 |
| $250 of spending | $265.40 | $359.00 |
See our refund policy for refund and balance terms.
Open the wallet →Add your own vendor API keys to your Oriora account, and AI calls go through your keys. The vendor bills you directly for AI cost; Oriora charges only its flat per-call fees ($0.001 per service layer used). Available across both BYOK lanes (Managed BYOK in catalog Apps and Managed API BYOK when you integrate Oriora into your own product).
Oriora's server handles only text and orchestration: AI responses, routing decisions, brief-to-output pipelines. It is not designed to carry binary files. Oriora apps that work with images, video, or large documents are built to route those files through GitHub Actions or direct CDN URLs — never through Oriora's server. These apps require you to connect your own GitHub account; that requirement is part of how the architecture is enforced, not an optional step.
If a response from Oriora's server exceeds 2 MB — which cannot happen under normal use, only if binary content is deliberately forced through a route not built for it — the connection is terminated immediately and a $0.01 data transfer feeis charged to your wallet. This rate reflects the disproportionate server infrastructure cost of an out-of-design request. Any account doing this consistently will be flagged and the affected routes closed. Until then, the costs are the user's to bear.
Under normal, intended use you will never see this charge.