Managed marketplace Managed only

Requesty

Hosted router with a flat 5% fee on inference, EU data residency and enterprise governance controls.

United Kingdom company — outside US jurisdiction · EU region available

Compare with others Estimate cost Visit site ↗

Access at a glance

Whether this product can work for you at all, before features matter: who pays the model bill, where it can run, and which of your existing API calls keep working. Every value is the vendor’s own claim, linked to the page it came from.

Routing proxy: "One API. 300+ models. OpenAI-compatible" and the docs call it a "pass-through gateway" that "normalizes the schema across models and providers through a single API" (Requesty quickstart, Inference APIs). Marketed as an "Enterprise AI Gateway" (Requesty Enterprise).

Who pays the model bill

Your keys or their credits

You can start on their credits and move to your own provider accounts later.

Platform credits ("New accounts include free credits to start routing immediately") plus BYOK ("Use your own API keys with Requesty… Choose between Requesty's keys or your own keys for each model") (quickstart, BYOK).

Merchant of record: Differs by mode. Credits: Requesty (account credits consumed per request, cost returned in usage) (quickstart). BYOK: the upstream provider — "Cost Control: Use your own billing relationships with providers" and "keep provider discounts and committed-use pricing" (BYOK, quickstart). Explicit invoicing language: not stated.

Key handling: Upstream keys are added per provider in the dashboard, "at most one key per provider", usable in fallback policies, with usage tracked across the organization (BYOK). Requesty's own API keys are "hashed at rest", shown once, and scoped service-account keys are supported; prompts may be logged up to 30 days unless disabled, and org-wide Zero Data Retention requires a written request (Security). Enterprise page claims zero data retention and no training on customer data (Enterprise). Encryption/KMS specifics for upstream keys: n.a.

Where it can run

3 of 5 shapes documented
  • Vendor-hosted
  • Self-host
  • Your VPC
  • On-premise
  • Air-gapped

Dimmed shapes are not documented by the vendor, which is not the same as unsupported.

Hosted SaaS (EU/Frankfurt region available) (Enterprise, Security). Self-host on Kubernetes via Helm, incl. air-gapped, is documented in a vendor blog post (Self-hosting Requesty on Kubernetes) while the enterprise page says self-hosting is "not offered at this time" (Enterprise) — see contradictions. — self_host and air_gapped are contested: a vendor engineering post documents a Helm/Kubernetes install including air-gapped, while the enterprise page states self-hosting is not offered at this time.

SaaS endpoints https://router.requesty.ai/v1 and https://api.requesty.ai/v1 (quickstart, Enterprise); the Helm guide covers a Kubernetes chart with /health and /ready probes and air-gapped installs (Helm guide). Enterprise tier gates SSO, RBAC, custom SLAs and EU residency (Enterprise).

API surfaces your code can keep using

6 of 7 documented
  • OpenAI chatPOST /v1/chat/completionsYes

    POST https://router.requesty.ai/v1/chat/completions (quickstart, Inference APIs).

  • Anthropic messagesPOST /v1/messagesYes

    POST /v1/messages, documented as https://router.requesty.ai/anthropic/v1/messages for the Anthropic SDK (Inference APIs, quickstart).

  • OpenAI ResponsesPOST /v1/responsesYes

    POST /v1/responses (Inference APIs).

  • EmbeddingsPOST /v1/embeddingsYes

    yes ("Create vector embeddings from text…"), documented under the inference API family (Inference APIs).

  • ImagesPOST /v1/images/generationsYes

    Image generation and editing "using DALL-E, Stable Diffusion, and other image models" (Inference APIs).

  • AudioPOST /v1/audio/*Yes *

    yes, both: Text to Speech and Speech to Text endpoints (Inference APIs).

  • Batch jobsPOST /v1/batchesNot documented

    n.a. (no batch/async bulk endpoint on any Requesty page fetched: Inference APIs, quickstart).

An asterisk marks a qualified verdict: support that is indirect (SDK compatibility or provider passthrough rather than a native endpoint), or a gap that is narrower or wider than the label suggests. Read the note before porting.

Drop-in base-URL swap: "If you're already using the OpenAI SDK, point it at Requesty and you're done. No SDK changes, no new client to learn"; LangChain, Vercel AI SDK, LlamaIndex, Haystack and Pydantic AI work out of the box (quickstart). Streaming caveat: you must pass stream_options: {"include_usage": true} to get a final usage chunk (quickstart). Model IDs are provider-prefixed (e.g. openai/gpt-4o) (quickstart).

How much it reaches

Models160–600vendor pages disagree
Upstream providersNot published

Models: The vendor publishes different totals on different pages; both bounds are shown.

"300+ models" on the docs (undated) (Supported models, quickstart); "600+" AI models on the enterprise page (undated) (Enterprise); "160+ supported models" in the self-hosting blog post (Helm guide). See contradictions.

n.a. as a number. The BYOK page lists 6 connectable providers (OpenAI, Anthropic, Google AI Studio, Vertex AI, Mistral AI, xAI) and says "More providers will be added over time"; the models page names OpenAI, Anthropic, Google, DeepSeek, xAI, Mistral "and more". Both pages undated (BYOK, Supported models).

Whose models: Routed to third-party providers; open-source models are "Hosted or bring-your-own endpoints" (quickstart). No Requesty-owned inference hardware is claimed on any page fetched.

Your own endpoints: Partially documented: the quickstart lists "bring-your-own endpoints" for open-source models (quickstart), but no page fetched documents how to register a vLLM/Ollama/SageMaker URL — mechanism n.a.

How it behaves in production

What happens when an upstream model is slow, wrong, or down — and what you can see and stop while it happens. Reliability features are recorded as where you configure them, not whether the vendor lists them, because almost every product here lists all of them.

0 of 6 reachable from code0 of 4 can blockno documented export

When something goes wrong

Each row says where the knob is, not whether the feature is on the marketing page. A control you can only reach by hand in someone else’s dashboard cannot be reviewed or version-controlled.

  • Request timeoutNot documented

    The vendor does not document this, so any behaviour you observe today is unversioned and may change.

    No timeout header or key on the fetched fallback/load-balancing/latency-routing/limits pages (Requesty API limits).

  • RetriesDashboard only

    Only reachable by hand in the vendor UI, so it cannot be reviewed, version-controlled, or changed from code.

    Retries are part of a policy configured in the Requesty console: 0–10 retries per model, exponential backoff 500ms → 1s → 2s → 4s with ±10% jitter (Requesty fallback policies).

  • Fallback to another modelDashboard only

    ORDERED. Fallback policies are created in the dashboard and referenced from the request as policy/<name> in the model field (Requesty fallback policies).

  • Load balancingDashboard only

    Weights ARE supported and must total 100% across the models in a load-balancing policy (Requesty load balancing policies).

  • Upstream health trackingNot documented

    No upstream health check, circuit breaker or provider-ejection mechanism is documented on the fetched pages; latency routing selects by observed latency instead (Requesty latency routing).

  • Cross-region failoverNot documented

    Regional Bedrock endpoints can be targeted as separate models, but no cross-region failover feature is documented (Requesty load balancing policies).

Fallback chain: Ordered list — Try A, then B, then C. Simple and predictable, but every failover is all-or-nothing.

Everything reliability-related is a named dashboard "policy" invoked as policy/<name> in the model field, so reliability config is not in your repo and not per-request (Requesty fallback policies).

How fast the hop is

Undisclosed vendor service

The vendor does not disclose what the request path runs on, so no overhead floor can be inferred at all.

Runtime is never disclosed on the fetched pages; only the hosted endpoint https://router.requesty.ai/v1 is documented (Requesty streaming).

You can run the request path yourselfNot documented
StreamingYes

No self-host artifact appears on the fetched pages (Requesty streaming).

Streaming caveats: Supported over Server-Sent Events with "stream": true. Caveats: streaming responses do not include a usage object by default — you must pass stream_options: {"include_usage": true}, which adds an extra chunk before data: [DONE] with an empty choices array; the docs also tell you to implement your own retry/non-streaming fallback for stream interruptions (Requesty streaming).

Published figures, grouped by what each one measured. Figures in different groups are different quantities and cannot be compared with one another — nor, in most cases, with another vendor’s figure in the same group.

Marketing claim, not a measurement

Fleet totals and unquantified claims. Recorded here because it is all the vendor published, not because it means anything operationally.

  • up to 80% lowerperceived wait timeVendor-published

    Streaming marketing claim. Not a gateway-overhead measurement; conditions not stated.

    Source

The single "up to 80%" figure is a vendor claim about its own product, with no methodology (Requesty streaming).

What it will stop

0 of 4 can block

Two separate questions per control: can it stop a request at all, and what does it do before you change any settings? A control that inspects and forwards is a logging feature, however it is named.

  • Personal data in promptsInspects but lets it through

    Out of the box: Only logs until you change it

    PII scanners (pii/v2/fast, pii/v2/ml) support actions Disabled, Report, and Mask; masking rewrites the request but the docs document no hard block/deny action (Requesty Guardrails)

  • Prompt injection and jailbreaksNot documented

    The guardrails page documents PII and secrets scanners only (Requesty Guardrails)

  • Harmful contentNot documented

    No toxicity/moderation scanner documented (Requesty Guardrails)

  • Your own policiesNot documented

    Policy form is a choice of vendor-supplied scanners plus an action; no regex, word list, or JSON-schema enforcement documented (Requesty Guardrails, Managed policies)

Where checks runOn the vendor's servers
If the guardrail itself failsNot documented

Almost no vendor in this catalogue documents what happens when the guardrail service itself times out. If the control matters to you, this is a question worth asking before you sign.

No timeout or failure behaviour stated (Requesty Guardrails)

Guardrail verdicts are written into the logs, so Requesty's scanners function primarily as inline detectors with masking, and the docs never promise request denial (Requesty Guardrails).

What you can see

No documented export
What gets loggedFull prompts and responses

Prompt and completion bodies are stored by default. Powerful for debugging, and a data-residency question you have to answer before you ship.

You can turn bodies offNot documented

No documented header or setting to suppress bodies while keeping metrics (Requesty Logs)

TracesOpenTelemetry

Requesty groups related requests into Traces keyed by trace_id, giving multi-step visibility; OpenTelemetry support is not documented (Requesty Logs)

The Logs view shows full message history for a request, i.e. prompt and completion text is stored (Requesty Logs)

Where telemetry can go

No documented export. Whatever this product records stays in its own interface, so it cannot become part of the monitoring you already run.

n.a. — No external log/metric/trace destinations documented (Requesty Logs)

Records user feedbackPartly
Scores live trafficNo

Logs carry a Feedback column, but no feedback API endpoint or header is documented (Requesty Logs)

n.a. — No eval or scoring product documented (Requesty Logs)

Retention: n.a. — No retention window stated (Requesty Logs)

Whether it fits how you work

How much work stands between you and a first call, how different that is from running it in production, and whether it slots into the stack you already have. Recorded as the shape of the work rather than a number of minutes — how long it takes you depends on which accounts and quota you already hold, which no comparison can know.

to try: base url swapto run: base url swapfits 7 of 10 common stacks

Getting to a first call

4 numbered steps
Shape of the workChange one base URL

Your existing OpenAI-compatible client keeps working. You change a base URL and a key, and nothing else in your code moves.

Read off: the vendor’s own quickstart — 4 numbered steps.

Before step one

  • Your own provider keyNot needed

    You can make a first call with only this product’s key. No upstream provider account needed.

    . Only REQUESTY_API_KEY is needed; "Bring your own keys" is listed as an optional feature (Quickstart - Requesty Docs)

  • Payment methodNo card needed to start

    Not stated as required; "New accounts include free credits to start routing immediately." (Quickstart - Requesty Docs). Enterprise page: "You can start on the pay-as-you-go plan with no commitment" (Requesty Enterprise)

  • Gate before models answerNo gate

    Every catalogue model is callable as soon as you have a key.

    For self-serve: "Every model lives behind one endpoint. Swap model in the request to switch providers." (Quickstart - Requesty Docs). Restriction is an admin option, not a gate: "Enterprise plans let admins restrict access to an approved list of models and providers" (Requesty Enterprise)

Everything you need first: A Requesty account ("Sign up at app.requesty.ai") and an API key exported as REQUESTY_API_KEY. No credit card, cloud account, cluster, or separate provider key is stated (Quickstart - Requesty Docs)

The vendor’s own time claim: Vendor claim, verbatim: "One API. 300+ models. OpenAI-compatible. Route your first request in under 2 minutes." (Quickstart - Requesty Docs) Quoted, not verified. Marketing time claims assume every account and approval is already in place.

Running it in production

The same scale applied to the path the vendor recommends for production traffic. Kept separate from the quickstart because for several products here the two are barely related pieces of work.

Shape of the workChange one base URL

Your existing OpenAI-compatible client keeps working. You change a base URL and a key, and nothing else in your code moves.

What production needs: Nothing infrastructural; enterprise adds a sales-led path of 3 steps ("Talk to our team" → "Custom onboarding" → "Go live") and "Enterprise plans are priced on request" for SSO/RBAC/SLA (Requesty Enterprise)

Can you run it yourself

Install command publishedNo self-hosting

This runs on the vendor’s infrastructure only.

How it fits your stack

7 of 10

Each row is a thing you might already run. “With a caveat” means it works but not the way the vendor’s marketing implies — read the reason, because that is usually where the surprise lives.

  • FitsThe OpenAI SDKDrop-in: change the base URL and key, nothing else.
  • FitsThe Vercel AI SDK@requesty/ai-sdk
  • FitsCloudflare WorkersCalling it from a Worker is documented.
  • FitsKubernetesHelm repo https://helm.requesty.ai (chart name not stated)
  • NoTerraform or OpenTofuNothing published for Terraform.
  • NoAn existing API gatewayNothing published about running behind your gateway.
  • NoCloud IAM I already runNo identity integration published.
  • FitsLangChain or LlamaIndexLangChain, LlamaIndex
  • FitsMCP servers to governActs as an MCP gateway or registry.
  • FitsNothing — plain Node or PythonChange one base URL.

Reading this the other way round — pick what you already run and see every product scored against it.

The integration surfaces behind those answers

  • Vercel AI SDKOfficial provider package

    Install the package, swap the model factory, done. Maintained by a party with a stake in it.

    Named: @requesty/ai-sdk

    Yes. The official Vercel AI SDK provider package is @requesty/ai-sdk, with the provider instance requesty imported from @requesty/ai-sdk. (Requesty Vercel AI SDK docs)

  • Cloudflare WorkersDocumented from your Worker

    The docs show calling this product from inside a Worker, including the runtime flags you need.

    Requesty can run behind Cloudflare Workers, which can handle authentication, rate limiting, request validation, forwarding, response caching, and global edge deployment. (Requesty behind Cloudflare Workers)

  • KubernetesOfficial Helm chart

    A named, published chart. You can read its values file before committing to anything.

    Named: Helm repo https://helm.requesty.ai (chart name not stated)

    Requesty documents self-hosting on Kubernetes, including air-gapped environments. The official Helm repository is named requesty and is located at https://helm.requesty.ai; the chart name is not stated. (Requesty Kubernetes Helm deployment guide)

  • TerraformNot documented

    No Terraform surface published. Configuration is API or dashboard work.

    n.a. (not documented)

  • Existing API gatewayNot documented

    Nothing published about sitting behind an existing gateway. Treat it as a separate hop you route to yourself.

    n.a. (not documented)

  • Cloud identityNot documented

    No identity integration published. Expect API keys in a secret store.

    n.a. (not documented)

  • MCPMCP gateway or registry

    It sits in front of many MCP servers and governs access to them. This is the shape you want if MCP sprawl is the problem you are solving.

    Requesty provides an MCP Gateway that authenticates and routes requests to multiple MCP servers, supports tool discovery and whitelisting, and integrates with MCP-compatible tools such as Claude Code, Cursor, and Roo Code. It supports streamable-http and sse; stdio is coming soon, and the Roo Code endpoint is https://router.requesty.ai/mcp. (Requesty MCP Gateway docs)

Python frameworks
  • LangChain
  • LlamaIndex

Requesty documents LangChain integration using langchain_openai.ChatOpenAI, langchain_core.prompts.PromptTemplate, and langchain_core.runnables.RunnableLambda. LlamaIndex is also documented as an integration, including a TypeScript integration, but its package and class names are not stated. (Requesty LangChain framework docs)

First-party client libraries
  • Python
  • TypeScript

Requesty documents the OpenAI SDK for Python and TypeScript/Node.js using the openai package, installed with pip install openai or npm install openai, and the OpenAI client class. The Anthropic SDK is also documented through https://router.requesty.ai/anthropic/v1/messages; cURL requires no installation. (Requesty quickstart)

Agent features: Requesty documents function calling, agent routing policies with preferred models, fallback chains, and cost caps, and agent analytics for latency, cost, and success rates. Session reconstruction can replay full conversation sessions for debugging; sessions/threads as an agent primitive, multi-step orchestration, and A2A are not stated. (Requesty homepage)

Only two config changes are required (Requesty key instead of OPENAI_API_KEY, Requesty base URL instead of https://api.openai.com/v1); an Anthropic-SDK path exists at https://router.requesty.ai/anthropic/v1/messages; OpenAI-compatible frameworks (LangChain, Vercel AI SDK, LlamaIndex, Haystack, Pydantic AI) "work with Requesty out of the box" (Quickstart - Requesty Docs)

Requesty is documented as a hosted, OpenAI-compatible gateway with unified routing, fallback, caching, analytics, BYOK, and access to hundreds of models through a single endpoint; documented model counts include 300+ and 600+. Official evidence also documents EU routing at https://router.eu.requesty.ai/v1 and self-hosting on Kubernetes, including air-gapped deployments. (Requesty homepage)

Silence in the docs: 3 of the integration questions on this card have no published answer either way. That is recorded as undocumented, not as a no — but it does mean you would be verifying it yourself.

What it does well

  • Flat 5% fee with no seat fees, no minimum spend and no top-up fee
  • 0% markup when bringing your own provider keys
  • EU-only routing endpoint with in-region logging, caching and analytics
  • Semantic caching, PII redaction, guardrails and budget controls
  • Public models endpoint returning live pricing

Where it falls short

  • 5% markup is charged on every token, unlike zero-markup gateways
  • Its own pages state 600+, 400+ and 300+ models inconsistently
  • SOC 2 Type II is only in progress, not attested
  • Governance features (RBAC, PII detection, guardrails, SSO) are gated to Enterprise
  • Managed SaaS only: no self-hosting, VPC or air-gapped option

Choose it when

European teams that want one router with EU data residency, PII scrubbing and a predictable flat 5% fee.

Look elsewhere when

You need a zero-markup gateway, a completed SOC 2 attestation today, or a self-hosted deployment.

Managed marketplace: One account and one key gets you hundreds of models from dozens of providers. Fastest way to start, widest catalog, least control over the data path.

How hard is it to leave?

Derived from six published facts, not from an opinion. The weights are fixed and the same for every product — see the arithmetic.

64/100Some work to leave
Portability score breakdown for Requesty
What helps you leave Points Source
Works with standard OpenAI codeSwitching away is a base-URL change rather than a rewrite of every call site.22/22 vendor page
No vendor-specific SDK requiredA proprietary client library spreads through your codebase and has to be torn out again.10/10 vendor page
Can use your own provider accountsYour keys and billing relationship stay yours, so removing the gateway does not cut off model access.20/20 vendor page
Can be self-hostedYou can run it yourself instead of accepting a pricing or policy change.0/20 vendor page
Configuration lives in version controlRouting and budget rules are a file you keep, not dashboard state you would have to rebuild.0/16 vendor page
Your request history can be exportedYou leave with your own logs instead of abandoning them.12/12 vendor page

Read the fine print: Analytics export is CSV/PDF summaries.

All six inputs are published, so this is scored against the full 100. This measures technical switching cost only. It does not price the engineering time to re-test prompts against a different routing stack.

Full specification

Every field we track. Blank fields say "Not published" rather than "No" — we do not infer an absence from silence. Switch to Technical in the header for the precise field names and the low-level details.

Overview

What kind of product Category
Managed marketplace Not verified
Marketplaces resell many providers behind one key. Gateways add governance on top. Open-source projects you run yourself. Cloud platforms are hyperscaler surfaces. Inference providers host models on their own hardware.
Who runs it Deployment model
Managed only Verified 2 days ago
Managed means the vendor operates it. Self-host means you run it on your own infrastructure. Both means you can choose.
Licence Licence
Not published Not verified
Proprietary products cannot be inspected or forked. Open licences such as MIT and Apache-2.0 let you audit, modify, and run the code without permission.
Company Company
Requesty Not verified
The organisation that maintains the product.
Who you would be signing with Vendor status
Independent company Not verified
Whether the product is still an independent company, has been acquired, is a large cloud vendor’s product line, is run by a software foundation, or has been put into maintenance mode. Maintenance mode means bug fixes and security patches only — no new features.
Last shipped an update Latest release
2026-08-26 Not verified
The date of the most recent release or version tag. A product that has not shipped in a year is a different risk from one that shipped last week, regardless of what its marketing site says.
GitHub stars GitHub stars
Not published Not verified
A rough proxy for community size on open-source projects. Not a quality measure.

Cost

Markup on model prices Token markup
5% Verified 2 days ago
How much the product adds on top of what the underlying model provider charges. Zero means you pay the same per-token price you would pay the model provider directly.
Fee to add funds Credit purchase fee
Not published Not verified
A percentage charged when you top up your balance, separate from token prices. It is easy to miss because it does not appear on the per-token price list.
Monthly cost per person Seat fee
None Verified 2 days ago
A recurring per-user platform charge that applies regardless of how much you use the models.
Can use your own provider accounts BYOK supported
Yes Verified 2 days ago
Bring Your Own Key: you keep direct contracts with OpenAI, Anthropic and others, and the gateway only routes traffic. This preserves negotiated rates and committed-spend discounts.
Cost of using your own accounts BYOK terms
0% markup on your own provider contracts when using BYOK; keeps negotiated provider and committed-use pricing. Verified 2 days ago
What the product charges to route traffic through your own provider keys.
Free tier Free tier
Free plan: all free models, 200 requests/day, routing, caching, fallbacks, EU residency, no credit card. Verified 2 days ago
What you can do without paying, useful for evaluation.
Enterprise plan from Enterprise plan from
Not published Not verified
Annual entry price for the enterprise tier, where one is published or credibly reported.
Cost to run it yourself Self-host cost
Not published Not verified
What self-hosting actually costs once you account for infrastructure and any paid tier.
How the vendor makes money Pricing model
Percentage on tokens or top-ups Not verified
The shape of the vendor’s bill: does the routing layer charge a percentage on top of tokens, a flat monthly fee, both, neither (because inference is the product), or nothing at all (open source with no paid tier).
How pricing works, briefly Pricing model detail
Flat 5% per-token markup, no seats, no minimum spend. Free tier caps free-model use at 200 req/day; Enterprise is custom. Not verified
A one-paragraph description that covers the caveats a pricing category cannot: introductory rates, per-feature meters, tier gating, and pricing that resets on a specific date.
Minimum commitment Minimum commitment
None — 'no minimum spend'. Not verified
Whether the vendor requires a minimum contract term, a minimum spend, or a provisioned-capacity purchase to get its published rate.
Charges that fire after you go over an allowance Overage terms
No retention, request-volume or export overage stated on the pricing page. Not verified
The line items that scale with usage after an included allowance is exhausted — log storage, extra requests, per-feature meters, data export — which is where cost estimates usually go wrong.
Prompt cache offered Cache mechanism
Passes provider caching through Not verified
Whether the gateway offers its own response cache, what kind of match it does (exact request, prefix, semantic), or simply passes provider caching through unchanged.
Discount on cached input Cache-read discount
90% Not verified
How much cheaper cached tokens are than fresh input, when the vendor publishes a single figure. Bundled-inference clouds usually price this per model instead of as one number.
Premium on cache writes Cache-write premium
Not published Not verified
How much more the first write of a cached prefix costs versus a plain input token. A high write premium and a low hit rate can leave you paying more than you save, so this matters as much as the read discount.
Who captures the cache saving Cache economics
Passthrough of provider caching with automatic breakpoint insertion; Requesty explicitly does not store responses server-side. Vendor says cache hits are billed 'at a fraction of the normal input token cost (up to 90% savings)'; cache writes 'have extra costs' for some providers, no number published. A per-request `false` toggle lets you avoid write premiums. Not verified
Whether the customer keeps the full saving from caching or the vendor captures part of it — and any conditions attached (write premium, storage fees, best-effort hits).
What you can split spend by Cost attribution
Per API key and per service account (each carries its own cap and usage). User/team/tag/customer splits listed as feature names without confirmation. Not verified
The dimensions the vendor documents for splitting spend — per key, per user, per team, per tag, per customer. Matters if you need to chargeback internally or bill an end customer.
How you get cost data out Cost export
'Data exports' is listed in the comparison table; a Management API can be queried programmatically. Specific formats (CSV/S3/warehouse) not stated. Not verified
The mechanisms the vendor publishes for exporting cost and usage data: CSV, an API, webhooks, S3, a data warehouse, or nothing at all. Any per-unit price is included.
Who pays the model bill BYOK mode
Your keys or their credits Not verified
Whether you bring your own provider accounts (BYOK), buy inference from this vendor, or can do either. This is the single biggest commercial difference between these products: it decides who holds the contract with the model provider and who carries the spend.

Spend governance in detail

Seven signals matter when a bill starts to hurt: who can spend, how much, on what, and who gets paged when it goes wrong. Everything below is drawn from the vendor’s own pricing and docs pages — how we read these.

  • Virtual or scoped keysYes

    Keys that carry their own budget and rate-limit policy, so an intern experiment cannot spend against a production budget.

    Org admins issue keys; policies scope to a key.

  • Budget caps per keyYes

    A dollar or token ceiling attached to an individual key. Where enforcement is soft, one over-limit request still completes before the block kicks in.

    Each API key has its own monthly spend cap, also per service account; enforced pre-request.

  • Budget caps per team or workspaceYes — enterprise

    A ceiling applied at a higher scope than one key — a team, a workspace, a customer, or an entire environment.

    'Groups & team budgets' listed; 'Teams, groups & spend controls' is an Enterprise bullet. Tier assignment ambiguous.

  • Rate limiting as a cost controlNo

    Configurable request-per-time-window caps. Platform-set rate limits do not count as spend controls; user-configurable ones do.

    Requesty imposes no rate limits of its own; upstream 429s are handled by routing retries.

  • Model allowlistsYes — enterprise

    A policy that constrains which models a key or team can call, keeping expensive frontier models out of the wrong hands.

    'Approved models & policies' is an Enterprise bullet; 'Approved models whitelist' in the comparison table.

  • Spend alertsYes

    Alerts fired as spend approaches a threshold. Alerts that only fire after the meter has rolled over are marked as such.

    Slack + webhook alerts fire as limits are approached (reported after spend).

  • Webhook notificationsYes

    Programmatic notifications on spend events, so budget breaches can page an on-call or open a ticket.

    Webhook alerts on approaching spend limits.

Enforcement:Enforced before each request

Catalog

Models available Models available
160–600 Verified 2 days ago
How many models you can call, shown as a range because several vendors publish different totals on different pages. Vendor-reported either way, so counts are not directly comparable — some count every provider variant of the same model separately.
Model providers reachable Upstream providers
Not published Verified 2 days ago
How many distinct model providers or labs you can reach, shown as a range where the vendor’s own pages disagree. More providers usually means better redundancy when one has an outage.
Works with standard OpenAI code OpenAI-compatible API
Yes Verified 2 days ago
If yes, you can usually switch to it by changing one base URL, and switch away just as easily. This is the main defence against lock-in.
OpenAI chat endpoint POST /v1/chat/completions
Yes Not verified
The endpoint almost every application ports first. "Not documented" means the vendor never states it, which is different from a documented no.
Anthropic messages endpoint POST /v1/messages
Yes Not verified
Whether Anthropic-shaped calls work without rewriting them. Several products support this only as SDK compatibility or provider passthrough rather than a native endpoint — the detail page says which.
OpenAI Responses endpoint POST /v1/responses
Yes Not verified
The newer stateful OpenAI surface. Support is much thinner across this market than chat completions.
Embeddings endpoint POST /v1/embeddings
Yes Not verified
Whether you can generate vectors through the same gateway, or need a second integration for retrieval workloads.
Image generation endpoint POST /v1/images/generations
Yes Not verified
Whether image models are reachable through the same surface as text.
Audio endpoints POST /v1/audio/*
Yes Not verified
Speech-to-text and text-to-speech. Frequently the first gap in an otherwise complete gateway.
Batch jobs endpoint POST /v1/batches
Not documented Not verified
Asynchronous bulk processing, usually at a discount. Commonly undocumented, and commonly the reason a migration stalls late.
Needs the vendor’s own code library Requires a vendor-specific SDK
No Verified 2 days ago
A proprietary client library spreads through your codebase and has to be torn out again if you leave. “No” is the better answer here, and it means the standard OpenAI client works.
You can export your request history Logs / usage data export
Yes Verified 2 days ago
Whether you can get your own request logs, traces, or usage records back out — through an API, a bulk export, or a download. Decides whether you leave with your history or abandon it.
Settings can live in version control Declarative config-as-code
No Verified 2 days ago
Whether routing, fallback, and budget rules can be declared in a file you keep in Git, rather than existing only as settings clicked into a hosted dashboard.
Embeddings Embeddings
Yes Verified 2 days ago
Text-to-vector models, needed for search and retrieval features.
Image generation Image generation
Yes Verified 2 days ago
Whether image models are reachable through the same interface.
Speech and audio Speech and audio
Yes Verified 2 days ago
Text-to-speech or transcription models through the same interface.
Video generation Video generation
Not published Not verified
Whether video models are reachable through the same interface.
Batch processing Batch processing
Not published Not verified
Submitting large jobs for cheaper, slower processing. Often 50% off for work that is not time-sensitive.

Routing & reliability

Uptime it promises in writing Contractual SLA uptime
99.99% Not verified
The uptime percentage in a published, contractual service level agreement. A public status page is not an SLA — it reports what happened, it does not promise anything or pay you back when it breaks.
Automatic failover Automatic failover
Yes Verified 2 days ago
When a model provider goes down or rate-limits you, traffic moves to a backup automatically instead of returning errors to your users.
Load balancing Load balancing
Yes Verified 2 days ago
Spreads requests across several providers or keys to raise your effective rate limit.
Rule-based routing Conditional routing
Yes Verified 2 days ago
Send different requests to different models based on rules — for example a cheap model for free users and a strong model for paying ones.
Response caching Response caching
Yes Verified 2 days ago
Reuses the answer when the exact same request comes in again, which cuts both cost and latency.
Similar-question caching Semantic cache
Yes Verified 2 days ago
Reuses an answer when a new question means roughly the same thing as an earlier one. Saves far more than exact-match caching but can return subtly wrong answers if tuned loosely.
Where you set the timeout Request timeout surface
Not documented Not verified

No timeout header or key on the fetched fallback/load-balancing/latency-routing/limits pages ([Requesty API limits](https://docs.requesty.ai/features/api-limits.md)).

Where a request timeout can be set: per request, in a config file, in the vendor dashboard, or nowhere. Nine of the twenty products documented here do not describe a request timeout at all, so the worst case of a hung upstream call is unknowable from the docs.
Where you set retries Retry policy surface
Dashboard only Not verified

Retries are part of a policy configured in the Requesty console: 0–10 retries per model, exponential backoff 500ms → 1s → 2s → 4s with ±10% jitter ([Requesty fallback policies](https://docs.requesty.ai/features/fallback-policies)).

Where retry count and backoff are configured. Worth knowing alongside billing: a retried streaming call can be charged more than once.
Where you set fallbacks Fallback surface
Dashboard only Not verified

ORDERED. Fallback policies are created in the dashboard and referenced from the request as `policy/<name>` in the `model` field ([Requesty fallback policies](https://docs.requesty.ai/features/fallback-policies)).

Where the fallback chain is defined. Almost every product claims fallback; the useful question is whether you can change it from code or only by hand in a dashboard.
Shape of the fallback chain Fallback shape
Ordered list Not verified
An ordered list tries targets in sequence; a weighted split sends a percentage of traffic to each, which is what you need to trial a new model on 5% of requests. Weighted splits are much rarer than the marketing implies.
Upstream health tracking Health checks / circuit breaking
Not documented Not verified

No upstream health check, circuit breaker or provider-ejection mechanism is documented on the fetched pages; latency routing selects by observed latency instead ([Requesty latency routing](https://docs.requesty.ai/features/latency-routing)).

Whether the product notices a failing upstream and stops sending traffic to it, and whether you can tune the thresholds. This is what turns a provider outage into a blip rather than a sustained error rate, and only four of the twenty expose it.
Cross-region failover you control Multi-region failover surface
Not documented Not verified

Regional Bedrock endpoints can be targeted as separate models, but no cross-region failover feature is documented ([Requesty load balancing policies](https://docs.requesty.ai/features/load-balancing-policies)).

Whether you can define what happens when a region degrades. A vendor running many regions is not the same as a vendor letting you configure failover between them; only three document a user-controlled mechanism.
Where you set load balancing Load balancing surface
Dashboard only Not verified

Weights ARE supported and must total 100% across the models in a load-balancing policy ([Requesty load balancing policies](https://docs.requesty.ai/features/load-balancing-policies)).

Where traffic distribution across upstreams or keys is configured.

Operations

Usage dashboards and logs Observability
Yes Verified 2 days ago
Built-in visibility into what was sent, what came back, what it cost, and how long it took.
Spending limits Budget controls
Yes Verified 2 days ago
Hard caps that stop spend before it becomes a surprise invoice. The single most valuable control for a small team.
Rate limits Rate limits
Yes Verified 2 days ago
Caps on request volume per key or per user, useful for protecting against abuse and runaway loops.
Separate keys per team or app Virtual keys
Not published Not verified
Issue scoped keys with their own budgets and permissions so you can attribute cost and revoke access without rotating everything.
Prompt versioning Prompt management
Yes Verified 2 days ago
Store and version prompts outside your code so they can be changed without a deploy.
Quality testing Evals
Not published Not verified
Built-in tooling to score model output against test cases, so you can tell whether a model swap made things better or worse.
MCP support MCP support
Yes Verified 2 days ago
Native support for the Model Context Protocol, the emerging standard for connecting models to external tools.
What gets logged Logged content
Full prompts and responses Not verified

The Logs view shows full message history for a request, i.e. prompt and completion text is stored ([Requesty Logs](https://docs.requesty.ai/features/logs))

Whether full prompts and responses are stored, only metadata, or nothing. Full-body logging is the most useful debugging feature here and the one most likely to need a conversation with your compliance team.
You can turn logging off Body-logging opt-out
Not documented Not verified

No documented header or setting to suppress bodies while keeping metrics ([Requesty Logs](https://docs.requesty.ai/features/logs))

Whether prompt and response bodies can be suppressed while still keeping usage metrics. Nineteen of the twenty document a way to do this; the mechanisms range from a per-request header to an organisation-wide setting.
Traces you can take elsewhere Distributed tracing
OpenTelemetry Not verified

Requesty groups related requests into Traces keyed by `trace_id`, giving multi-step visibility; OpenTelemetry support is not documented ([Requesty Logs](https://docs.requesty.ai/features/logs))

Whether the product emits OpenTelemetry, a proprietary format, or nothing. OpenTelemetry means the traces land in the tooling you already run instead of only in the vendor’s dashboard.
Where telemetry can go Export destinations
Not published Not verified

`n.a.` — No external log/metric/trace destinations documented ([Requesty Logs](https://docs.requesty.ai/features/logs))

Documented sinks for logs and metrics. This is a good proxy for how replaceable the vendor’s own dashboard is: around twenty destinations means you never have to depend on it, while a CSV download means you do.
Can record user feedback Feedback capture API
Partly Not verified

Logs carry a Feedback column, but no feedback API endpoint or header is documented ([Requesty Logs](https://docs.requesty.ai/features/logs))

Whether there is an API to attach a rating or score to a logged request, which is what lets production traffic feed quality work later.
Scores live traffic Online eval hooks
No Not verified

`n.a.` — No eval or scoring product documented ([Requesty Logs](https://docs.requesty.ai/features/logs))

Whether automated scorers can run against real production requests, rather than only against a test set you assemble yourself.

Performance

Delay it adds Proxy overhead
16 ms Verified 2 days ago
Extra time the product itself adds to each request, on top of however long the model takes. Usually irrelevant next to multi-second model latency, but it matters for high-volume or streaming-sensitive workloads.
Requests per second ceiling Throughput
Not published Not verified
Published sustained request rate before the product becomes the bottleneck. Only relevant at genuinely high volume.
What the request path runs on Architecture class
Undisclosed vendor service Not verified

Runtime is never disclosed on the fetched pages; only the hosted endpoint `https://router.requesty.ai/v1` is documented ([Requesty streaming](https://docs.requesty.ai/features/streaming)).

The comparable way to talk about latency here. An edge worker, a compiled Go or Rust binary, and a Python proxy have different overhead floors no matter which figures each vendor publishes. Products that never disclose their runtime are recorded as undisclosed rather than assumed.
You can run the request path yourself Self-hostable data plane
Not documented Not verified

No self-host artifact appears on the fetched pages ([Requesty streaming](https://docs.requesty.ai/features/streaming)).

Whether the component that actually carries your prompts can run on your own infrastructure. Distinct from a vendor offering a self-hosted control plane while still proxying traffic through their network.
Streaming responses Streaming support
Yes Not verified

Supported over Server-Sent Events with `"stream": true`. Caveats: streaming responses do not include a `usage` object by default — you must pass `stream_options: {"include_usage": true}`, which adds an extra chunk before `data: [DONE]` with an empty `choices` array; the docs also tell you to implement your own retry/non-streaming fallback for stream interruptions ([Requesty streaming](https://docs.requesty.ai/features/streaming)).

Whether token-by-token streaming is documented. The caveats matter more than the yes: some products cannot cancel a stream without still being billed, and several timeout and fallback mechanisms stop applying once the first token has been sent.

Security & compliance

Does your prompt reach their servers Prompt transits vendor
Yes Not verified

Hosted gateway; all traffic flows through Requesty's infrastructure in Frankfurt.

Whether the text you send passes through this company’s own infrastructure. If it does, every other promise on this page is a policy commitment rather than a physical impossibility. Self-hosted products can answer no outright.
What they keep if you change nothing Logging default
Yes — prompts and replies Not verified

On self-serve plans prompt and output logging is on by default, encrypted and held in the EU. You can disable it per API key.

Defaults matter more than options. A product that stores full prompts and replies unless you find the right header will have stored them by the time you read the docs.
How long they keep it Default content retention (days)
30 days Not verified

Thirty days on self-serve, reducible to zero by disabling logging per key.

Default retention for request content, in days. Zero means nothing is kept. Read the note: several products keep nothing as a rule but make timed exceptions for abuse review or specific models.
Could they train on your prompts Training on customer data
No Not verified

Absolute on any paid plan. The free plan is different: models labelled Training Permitted retain prompts and outputs and train on them, and those models are free-plan only.

Whether the vendor may use your prompts and outputs to train models. “Not published” means we could not find any position, which is not the same as a no — ask for it in writing.
Where it runs, and what you can pin Region and residency control
EU only — all infrastructure in Frankfurt, with an EU endpoint. No US region and no customer-VPC option. Not verified
Which regions are offered and whether you can force processing to stay in one. A global endpoint that silently picks a region is a different compliance story from an endpoint you pin yourself.
Where safety filters run Guardrail execution location
In the vendor’s cloud Not verified

Requesty runs its own PII detection model before the prompt reaches the model provider — inside its gateway, not yours.

A filter that strips personal data only helps if it runs before the data leaves your boundary. If guardrails execute in the vendor’s cloud, the vendor has already received whatever you wanted redacted.
Who else touches the data Subprocessor list
https://www.requesty.ai/privacy/subprocessors Not verified
The published list of third parties the vendor passes your data to. No list means you cannot know the full chain, which most data-protection agreements require you to.
SOC 2 audited SOC 2 audited
No Verified 2 days ago
An independent audit of security controls. Enterprise buyers and their procurement teams routinely require it.
Will sign a HIPAA agreement HIPAA BAA
Not published Not verified
Required before you may send protected health information through the service. Without a signed BAA, healthcare data is off limits.
GDPR commitments GDPR commitments
Yes Verified 2 days ago
Published data processing terms for handling personal data of people in the EU and UK.
Can keep data in the EU EU data residency
Yes Verified 2 days ago
Requests can be processed inside the EU rather than routed to US infrastructure. Often the deciding constraint for European customers.
Does not retain your data Zero data retention
Yes Verified 2 days ago
Prompts and responses are not stored after the request completes. Sometimes a paid add-on rather than the default.
Strips personal data PII redaction
Yes Verified 2 days ago
Detects and removes identifiers such as names, emails, and card numbers before the request reaches the model provider.
Content guardrails Content guardrails
Yes Verified 2 days ago
Policy checks on inputs and outputs — blocking unsafe content, enforcing formats, or catching prompt-injection attempts.
Runs fully disconnected Air-gapped deployment
No Verified 2 days ago
Can be deployed in a network with no internet access, which some regulated and defence environments require.
Blocks personal data in prompts PII / DLP enforcement
Inspects but lets it through Not verified

PII scanners (`pii/v2/fast`, `pii/v2/ml`) support actions Disabled, Report, and Mask; masking rewrites the request but the docs document no hard block/deny action ([Requesty Guardrails](https://docs.requesty.ai/features/guardrails))

Whether personal data detection sits on the request path and can stop the call, merely inspects and forwards it, or is not documented. A control that only reports is a logging feature, not a policy control.
Blocks prompt injection Injection / jailbreak enforcement
Not documented Not verified

The guardrails page documents PII and secrets scanners only ([Requesty Guardrails](https://docs.requesty.ai/features/guardrails))

Whether injection and jailbreak detection can stop a request. Most products offering this call a partner classifier rather than shipping their own.
Blocks harmful content Toxicity / moderation enforcement
Not documented Not verified

No toxicity/moderation scanner documented ([Requesty Guardrails](https://docs.requesty.ai/features/guardrails))

Whether hate, violence, sexual and self-harm categories are checked inline and can stop a request, in either direction.
Your own policy rules Custom policy hooks
Not documented Not verified

Policy form is a choice of vendor-supplied scanners plus an action; no regex, word list, or JSON-schema enforcement documented ([Requesty Guardrails](https://docs.requesty.ai/features/guardrails), [Managed policies](https://docs.requesty.ai/features/managed-policies))

Whether you can add your own rule — a regex, a webhook, or your own classifier — rather than choosing from the vendor library.
Where guardrails run Guardrail execution location
On the vendor's servers Not verified
Whether guardrail evaluation happens inside your infrastructure or on the vendor’s servers. This decides whether the prompt you are trying to protect leaves your network in order to be checked.
If the guardrail itself fails Guardrail failure mode
Not documented Not verified

No timeout or failure behaviour stated ([Requesty Guardrails](https://docs.requesty.ai/features/guardrails))

What happens when the guardrail service times out or errors: does the request proceed unchecked, or is it blocked? This is the worst-documented field in the entire catalogue — only two vendors state it plainly, which means most teams are running a control whose failure behaviour they cannot know.
Third-party guardrail vendors Guardrail integrations
Not published Not verified
Named external guardrail services the product can call. A long list means the product is a router for policy engines rather than a policy engine itself — which also means another vendor bill and another hop.

Compliance evidence

Graded by how strong the evidence is, not whether the word appears on the vendor’s website. An audited report and a marketing claim are different things, and only one of them will satisfy your own auditor.

  • SOC 2 In progress Type II expected Q3 2026
  • ISO 27001 Not published
  • GDPR DPA Available on request DPA on request; EU residency in Frankfurt
  • HIPAA BAA Not published
  • FedRAMP Not published
  • ITAR Not published

Vendor source

Fit & integration

Work to try it Evaluation work shape
Change one base URL Not verified
The shape of the work on the vendor’s own quickstart, from swapping one base URL through to deploying infrastructure. An ordinal class rather than a duration, because elapsed time depends on accounts and quota we cannot see.
Work to run it Production work shape
Change one base URL Not verified
The same scale applied to the vendor’s recommended production path. For several products this is much heavier than the quickstart, which is exactly why both are recorded.
Steps on the quickstart Numbered quickstart steps
4 Not verified
A literal count of numbered steps on the vendor’s quickstart, recorded as evidence beside the work shape. Zero means the page publishes no numbered procedure at all. Large counts usually mean interleaved language tracks rather than more work.
Can you self-host it today Self-host install documentation
No self-hosting Not verified
Whether an install command is actually published. Several products advertise self-hosting while publishing no command to start from, which a plain yes/no would hide.
Works with the OpenAI SDK OpenAI SDK drop-in
Yes Not verified

Yes. Requesty documents OpenAI SDK drop-in compatibility with `base_url="https://router.requesty.ai/v1"`; the EU endpoint is `https://router.eu.requesty.ai/v1`. ([Requesty OpenAI framework docs](https://docs.requesty.ai/frameworks/openai))

Whether an existing OpenAI-compatible client can be pointed at it by changing the base URL and key.
Vercel AI SDK support AI SDK provider package
Official provider package Not verified

Yes. The official Vercel AI SDK provider package is `@requesty/ai-sdk`, with the provider instance `requesty` imported from `@requesty/ai-sdk`. ([Requesty Vercel AI SDK docs](https://docs.requesty.ai/frameworks/vercel-ai-sdk))

Whether a first-party AI SDK provider package exists, or only a community package, a documented workaround, or the generic OpenAI provider pointed at a custom base URL.
Python framework integrations Documented Python frameworks
LangChain, LlamaIndex Not verified

Requesty documents LangChain integration using `langchain_openai.ChatOpenAI`, `langchain_core.prompts.PromptTemplate`, and `langchain_core.runnables.RunnableLambda`. LlamaIndex is also documented as an integration, including a TypeScript integration, but its package and class names are not stated. ([Requesty LangChain framework docs](https://docs.requesty.ai/frameworks/langchain))

LangChain, LangGraph, LlamaIndex and similar orchestration frameworks with a documented integration.
Callable from Cloudflare Workers Cloudflare Workers support
Documented from your Worker Not verified

Requesty can run behind Cloudflare Workers, which can handle authentication, rate limiting, request validation, forwarding, response caching, and global edge deployment. ([Requesty behind Cloudflare Workers](https://www.requesty.ai/blog/edge-deployments-running-requesty-behind-cloudflare-workers-1751655483))

Whether the docs show calling this product from your own Worker. Deliberately separated from the several products whose own gateway runs on Workers, which is a fact about their infrastructure and not about your edge compatibility.
Kubernetes install Helm chart availability
Official Helm chart Not verified

Requesty documents self-hosting on Kubernetes, including air-gapped environments. The official Helm repository is named `requesty` and is located at `https://helm.requesty.ai`; the chart name is not stated. ([Requesty Kubernetes Helm deployment guide](https://www.requesty.ai/blog/self-hosting-requesty-on-kubernetes-the-complete-helm-deployment-guide-1751655369))

Whether a named, published Helm chart exists, versus Helm being referenced with no chart named, versus generic cluster documentation that has nothing to do with this product.
Terraform support Terraform provider or modules
Not documented Not verified

n.a. (not documented)

Whether you can declare this in code: an official provider, official modules, resources inside a hyperscaler’s provider, a community provider, or only Terraform code shipped in a repo.
Reuses your cloud identity Cloud IAM reuse
Not documented Not verified

n.a. (not documented)

Whether you can authenticate with IAM roles, workload identity or managed identities instead of another long-lived API key. Distinguished from products that only accept static upstream provider credentials.
Fits behind your API gateway API gateway integration
Not documented Not verified

n.a. (not documented)

Whether AI traffic can go through a gateway you already run, and who documented that — the product’s vendor or the gateway’s.
MCP support MCP surface shape
MCP gateway or registry Not verified

Requesty provides an MCP Gateway that authenticates and routes requests to multiple MCP servers, supports tool discovery and whitelisting, and integrates with MCP-compatible tools such as Claude Code, Cursor, and Roo Code. It supports `streamable-http` and `sse`; `stdio` is coming soon, and the Roo Code endpoint is `https://router.requesty.ai/mcp`. ([Requesty MCP Gateway docs](https://docs.requesty.ai/features/mcp-gateway))

Which kind of MCP support this is: a gateway that governs many MCP servers, a hosted MCP server you connect to, MCP tools accepted inside the completion API, or client tooling. These are different products behind one acronym.
Needs your own provider key Upstream provider key required
Not needed Not verified

No. Only `REQUESTY_API_KEY` is needed; "Bring your own keys" is listed as an optional feature ([Quickstart - Requesty Docs](https://docs.requesty.ai/quickstart))

Whether an upstream provider account and key must exist before your first call works. A prerequisite rather than a step, and it can differ between the hosted and self-hosted forms of the same product.
Gate before models work Model access gate
No gate Not verified

None for self-serve: "Every model lives behind one endpoint. Swap `model` in the request to switch providers." ([Quickstart - Requesty Docs](https://docs.requesty.ai/quickstart)). Restriction is an admin option, not a gate: "Enterprise plans let admins restrict access to an approved list of models and providers" ([Requesty Enterprise](https://www.requesty.ai/enterprise))

Whether an enablement click, a quota grant, a paid tier or an approval form stands between a valid key and a working model call.
Official client languages First-party client SDK languages
Python, TypeScript Not verified

Requesty documents the OpenAI SDK for Python and TypeScript/Node.js using the `openai` package, installed with `pip install openai` or `npm install openai`, and the `OpenAI` client class. The Anthropic SDK is also documented through `https://router.requesty.ai/anthropic/v1/messages`; cURL requires no installation. ([Requesty quickstart](https://docs.requesty.ai/quickstart))

Languages with a first-party client library. An empty list can still mean the product is usable from any language via an OpenAI-compatible SDK.
Back to top ↑

Official links

Independent coverage

Third-party analysis, walkthroughs and operator threads. We link criticism as readily as praise. Nothing here is written or published by the vendor, by a competitor listed on this site, or by an SEO content farm — how we vet these.

Written reviews and analysis 1

  • Requesty Tutorial: The Unified LLM Gateway DataCamp · Nov 2025 Independent step-by-step tutorial that builds against Requesty's OpenAI-compatible endpoint and compares its routing, caching and cost controls with OpenRouter and LiteLLM.

Video 1

What has changed here

No tracked value on this page has moved since it was first researched. Every figure still carries its original citation and check date.

Back to top ↑

Read the head-to-head

These pairs have a written verdict, not just a table.

Requesty vs OpenRouter Read the verdict →

Usually weighed against

Requesty vs OpenRouter Compare →