FastRouter vs. Requesty

Different premises. Honest fit-by-constraint comparison.

Requesty is the cleanest answer in the category for European teams that need GDPR-grade data residency. AWS Frankfurt hosting, zero data retention by default, automatic PII scrubbing, SOC 2 Type II, 5% markup, ~400+ models, smart routing with cascading fallbacks, and a Live Logs dashboard for real-time monitoring. They've raised funding (~$3M from 20VC), have 1,200+ EU customers, and the marketing positioning ("OpenRouter alternative Europe has been waiting for") is fair.

FastRouter is built for teams whose constraint is the depth of the gateway, not the geography of the data. 0% markup with BYOK, 7 routing strategies including the AI Auto Model Router, Smart and Automatic Evaluations on production traffic, GEPA prompt optimization, video evals, and MCP credential vaulting for agentic workloads.

If EU data residency is a hard constraint, Requesty is genuinely the right answer for most teams. If your constraint is "make my LLM stack smarter, cheaper, and more governable," FastRouter has the deeper feature set.

The four numbers most teams ask about.

1) Markup on inference

FastRouter: 0% with BYOK

Requesty: 5% markup

2) Routing strategies

FastRouter: 7 (incl. AI Auto)

Requesty: Smart routing + cascading fallback

3) Built-in evaluations

FastRouter: Smart + Auto + GEPA + Video

Requesty: Not in scope today

4) EU-only data residency

FastRouter: Multi-region; EU available

Requesty: EU-only by design

Feature matrix

Where the two diverge today. ✓ supported, ✗ not supported, ◑ partial

Where Requesty's positioning is most defensible

Requesty is hosted in AWS Frankfurt (eu-central-1). All processing happens within EU borders, there are no cross-border transfers, GDPR compliance is full, and a Data Processing Agreement is available on request. The zero-data-retention guarantee is structural — the gateway is a real-time proxy, not a logging platform that also proxies — so prompts and completions are never stored after delivery. Encryption is TLS 1.3 in transit and AES-256 at rest for the metadata that does get persisted.

For European teams whose compliance officer needs to sign off on "no US data transfers, ever," that single fact often closes the procurement conversation faster than any feature set on the FastRouter side could compete with. The marketing positioning — "OpenRouter alternative Europe has been waiting for" — is earned, not just claimed.

FastRouter offers EU regional deployment as a configuration option, with the same zero-data-retention defaults and equivalent encryption. For teams without a hard EU-only mandate, this is functionally equivalent. For teams with a strict mandate that the entire control plane must be EU-only, Requesty's "we don't even have a US region" architecture is a stronger story for compliance.

If your compliance officer's answer to "where does the data live" must be "Frankfurt, only Frankfurt, by design," Requesty wins that conversation.

Both routers work. The depth gap is real but specific.

Requesty's routing is a clean implementation: smart routing inspects request complexity and matches it to a model tier (cheap models for simple queries, premium for hard ones), cascading fallbacks chain primary → secondary → tertiary providers with sub-20ms failover, latency-based routing tracks live P50/P90/P99 and switches to fastest, and load balancing distributes across multiple providers simultaneously for reliability. The 99.9% uptime SLA is part of the pitch.

FastRouter's seven strategies cover the same ground and add three primitives Requesty doesn't expose today: category-based routing as a first-class strategy (map prompt classes to model groups without building complexity heuristics), weighted shuffle for explicit canary releases, and the AI Auto Model Router that selects per request from cost, latency, and quality signals fed by the eval layer.

For straightforward production routing, the gap is narrow. For teams that want to A/B route between models or have the gateway make per-request quality-aware decisions, FastRouter has more knobs.

The widest gap is here

Requesty's product surface is intentionally focused. Observability is real-time and useful, governance is well-designed, and routing is solid — but evaluations and prompt optimization aren't part of the current product. The team has signaled a focus on production gateway and observability rather than offline experimentation tooling.

FastRouter ships:

• Smart Evaluations — AI quality scoring on live production traffic. Surfaces the model that's actually delivering the best output for your use case automatically.
• Automatic Evaluations — background sampler that benchmarks competing models on your real traffic.
• GEPA — Generative Evolutionary Prompt Architecture iterates across prompt and model combinations for Pareto-optimal cost/quality.
• Video evaluations — compare model output on video inputs, exclusive in this category.

If your roadmap includes "we should know which model is actually best for each workload, continuously" — that's where FastRouter pulls clearly ahead. If you'd rather pair your gateway with a separate eval tool (Langfuse, Braintrust), Requesty is fine for the gateway role and Langfuse handles the rest.

Both have real governance. Different shapes.

Requesty's governance model is well-thought-through: Owner / Admin / Developer / Viewer roles with cascading permissions; budget enforcement at org → team → project → key levels with cascading caps; Approved Models lets org admins curate which models teams can call; virtual API keys per project with provider credential isolation; complete RBAC. PII redaction is automatic for emails, phone numbers, SSNs, and credit card numbers before requests reach the model. Audit trails cover the standard who/what/when/where surface.

FastRouter offers the same primitives plus MCP credential vaulting (agents and tool callers never see raw provider keys — the gateway injects credentials server-side) and workspace-level kill-switches that hard-stop spend. For agentic workloads where MCP servers are calling tools on behalf of the user, the credential vault closes a real exfiltration surface that Requesty doesn't address today.

5% vs 0% — context matters

Requesty charges 5% markup on model costs, $6 in starting credits, BYOK supported separately for teams that want their own provider keys, and volume discounts available at the Enterprise tier. The 5% covers the entire feature surface — routing, governance, observability, PII redaction, EU hosting.

FastRouter charges 0% markup on inference when you BYOK. Platform pricing is a flat managed-service fee instead of percentage-of-spend, which means the gateway tax doesn't compound as your usage grows.

At small scale (sub-$2K/mo), 5% is rounding error and Requesty's all-in pricing is genuinely simple. At larger scale ($10K+/mo), the 5% delta becomes meaningful: $500/mo at $10K, $5,000/mo at $100K. If EU residency is the deciding factor, the 5% is often a fair price for the constraint. If it's not, the 0%-markup math compounds in FastRouter's favor.

When Requesty is the right call

EU data residency is non-negotiable

• Frankfurt-only by design — full GDPR compliance
• Zero cross-border transfers, structurally
• The cleanest answer for European compliance

You want a simple, all-in-one EU gateway

• 5% covers everything — no plan tiers to navigate
• Real-time observability included
• Auto PII scrubbing built in

Your needs map closely to the EU-first product surface

• Cascading governance is well-designed
• Smart routing covers most production needs
• Live Logs dashboard is genuinely useful

You're a European startup buying European

• EU-headquartered vendor
• Local procurement and support
• Aligned regulatory and language fit

When FastRouter is the right call

You don't have a hard EU-only mandate

• 0% markup vs 5% — compounds at scale
• EU regional deployment available if needed later
• The EU constraint isn't paying for capability

You need evals and prompt optimization

• Smart + Automatic Evaluations on live traffic
• GEPA prompt optimization runs continuously
• Video evals — exclusive in the category

You're running agentic workloads with MCP

• MCP credential vaulting
• Per-tool budget caps and rate limits
• Audit trail across multi-step agent runs

You want deeper routing knobs

• 7 strategies including AI Auto Model Router
• Category-based routing as a first-class primitive
• Weighted shuffle for explicit canary releases

Pick the right tool for your situation

1) EU data residency is a hard, non-negotiable requirement ->

Use Requesty. Their EU-only positioning is the cleanest in the category and the rest of the product surface is solid.

2) You want EU residency but also need evals, MCP, and deeper routing ->

Use FastRouter with EU regional deployment. You get both the data residency and the deeper feature surface.

3) You don't have a residency mandate and your scale is meaningful ->

Use FastRouter. The 0% markup, evals, and routing depth compound favorably as you grow.

4) You're a European startup that wants to buy European ->

Use Requesty. The local-vendor argument is real for procurement and a fair reason to choose.

5) You're already on Requesty and bumping into the eval / MCP gap ->

Talk to FastRouter. Both are OpenAI-compatible; migration is a base URL swap and a key change.

Common questions

1) Is Requesty really EU-only?

Yes. AWS Frankfurt (eu-central-1) is the only hosting region — that's the architectural commitment. For teams whose compliance officer needs structural assurance that data never leaves the EU, that's the strongest answer in the category.

2)Does FastRouter have an EU region?

Yes — EU regional deployment is available for teams that need it, with the same zero-data-retention defaults. The architectural difference is that FastRouter is multi-region by design, while Requesty is EU-only by design. For most teams the functional outcome is the same; for teams with strict "control plane must be EU" mandates, Requesty's posture is structurally cleaner.

3) What about HIPAA?

FastRouter is HIPAA-compliant with a BAA on enterprise plans. Requesty's HIPAA status isn't explicitly confirmed in public materials we've seen — if HIPAA is on your requirements list, ask both vendors directly.

4) How does Requesty's "smart routing" compare to FastRouter's AI Auto Router?

Requesty's smart routing is a complexity heuristic — it inspects the request and routes to an appropriate model tier (small/fast for simple queries, large for hard queries). FastRouter's AI Auto Model Router goes further: it picks per-request from real-time cost, latency, and quality signals fed by the eval layer. Both are valuable; AI Auto adds a quality dimension that complexity-only routing can't.

5) How hard is migration between the two?

Both are OpenAI-compatible. The bulk of migration is endpoint and key changes. Workspace and team mappings translate cleanly; budget cap structures are similar. We help with cutover for production workloads.

6) Does Requesty support MCP?

MCP support isn't documented in Requesty's current public materials. If MCP and credential vaulting are on your roadmap, that's a real gap to weigh. FastRouter ships MCP credential vaulting as a first-class primitive.

7) What about the 5% markup at scale?

5% is fine at small scale and a meaningful line item at large scale. At $10K/mo inference that's $500/mo; at $100K/mo it's $5K/mo. If EU residency is the deciding factor, that's often a fair price for the constraint. If it's not, the math favors a 0%-markup model like FastRouter's.