LLM API aggregator: Fallback and Routing Buyer's Guide

LLM API aggregator: Fallback and Routing Buyer's Guide

What good is access to dozens of AI models if your application still fails when its first-choice provider does? The best LLM API aggregator for model fallback and routing is the one that preserves your application’s requirements when a model becomes unavailable—not simply the one with the longest catalogue.

That distinction matters because fallback and routing solve different problems. Fallback determines what happens after a request fails; routing determines where a request goes in the first place. A buyer needs both to work within acceptable limits for cost, response time, output quality and API compatibility. Switching models is not a successful recovery if the replacement cannot handle your tool calls or return the structured output your application expects.

The financial differences are equally consequential. OpenRouter’s comparison with LiteLLM, supplied for this November 2026 guide, states that OpenRouter charges a 5.5% fee on pay-as-you-go credit purchases, with a $0.80 minimum per purchase, despite applying no markup to provider inference prices. “No token markup” therefore does not mean “no gateway cost.”

Self-hosting changes the equation rather than eliminating it. OpenRouter’s comparison estimates that, at approximately $200 per month in infrastructure costs, LiteLLM becomes cheaper at roughly $3,600 in monthly model spending; that calculation should be treated as a scenario, not a universal break-even point. Engineering time, monitoring and incident response also belong in a buyer’s total-cost assessment.

This guide compares OpenRouter, LiteLLM, Portkey, Cloudflare AI Gateway and Vercel AI Gateway through practical purchasing questions:

• Fallback behaviour: Which failures trigger another attempt, and can you control the replacement models?
• Routing control: Can you express your application’s priorities rather than accept an opaque default?
• Compatibility: What happens to streaming, function calling and structured outputs when the destination changes?
• Operational visibility: Can your team identify which model served a request and investigate unsuccessful attempts?
• Total cost: How do inference charges, credit fees, subscriptions and self-hosting expenses affect your actual bill?

As of November 2026, CallMissed’s verified product information lists an OpenAI-compatible developer API with caller-chosen fallback models, bring-your-own provider keys, and usage and request logs—capabilities relevant to this broader shift toward configurable AI access.

The aim is not to crown a universal winner. It is to help you distinguish a convenient model marketplace from a gateway that fits your production requirements, then build a shortlist around evidence. You will learn what to verify before purchasing, which trade-offs deserve a live test, and how to evaluate fallback beyond the reassuring promise that another model will answer.

For managed aggregation, shortlist OpenRouter; for self-hosted control, shortlist LiteLLM. Choose your fallback and routing fit through failure tests, compatibility checks and total-cost comparisons.

Shortlist OpenRouter for managed aggregation and LiteLLM for self-hosted control. The best AI API aggregator for model fallback and routing is the one that passes your failure, compatibility and cost tests—not a universal winner.

Which AI API aggregator belongs on your shortlist?

• OpenRouter: Choose this starting point when you want a managed routing layer rather than another service to operate. OpenRouter’s comparison, supplied for this November 2026 guide, describes the request path as application → OpenRouter’s Cloudflare edge → provider; evaluate that arrangement against your deployment requirements before committing.
• LiteLLM: Choose this starting point when running the gateway inside your infrastructure is a purchasing requirement. OpenRouter’s November 2026 comparison describes a LiteLLM deployment using Docker and PostgreSQL. Include deployment, database maintenance, monitoring and incident ownership in the decision; self-hosting gives your team responsibilities as well as control.
• Other candidates: Keep Portkey, Cloudflare AI Gateway and Vercel AI Gateway on the comparison list when their commercial models suit your requirements. The fp8.co comparison supplied for November 2026 describes hosted Portkey plans, free Cloudflare core features and zero token markup for Vercel, including BYOK; these pricing distinctions do not establish fallback quality.

How should you test fallback and routing before buying?

• Failure coverage: Run separate tests for 429 rate limits, 5xx provider errors and timeouts; treat these as proposed test cases, not verified capabilities of every gateway. Record whether each failure triggers recovery, which replacement receives the request, how many attempts occur and whether the application’s deadline survives the retry sequence.
• Compatibility coverage: Repeat your tests with streaming, function calling and structured outputs enabled. Require the replacement model to preserve the application’s contract, not merely return text. Include a stream interrupted after its first output: recovery before generation and recovery after partial delivery are different operational problems.
• CallMissed: As of November 2026, CallMissed’s verified fact sheet lists OpenAI-compatible and Anthropic-compatible endpoints, caller-chosen fallback models, structured outputs and request logs. Those capabilities justify a targeted compatibility evaluation alongside the shortlist; they do not establish automatic routing policies or successful recovery for every failure case.

How do you compare the total cost fairly?

• BYOK fees: OpenRouter’s comparison supplied for November 2026 states that bring-your-own-key usage carries a 5% fee on equivalent OpenRouter cost after a plan-dependent free allowance. Request the applicable allowance and calculate charges using expected usage; supplying provider credentials should not be assumed to eliminate gateway fees.
• Self-hosting economics: OpenRouter’s November 2026 comparison estimates a LiteLLM break-even point near $9,100 monthly model spending with $500 monthly infrastructure costs. Treat that as a scenario, not a buying rule: add engineering labour, monitoring and incident response, then compare gateways using total cost per successfully completed application task rather than token price alone.

Who needs an LLM API aggregator, and when is a gateway the wrong purchase?

An LLM API aggregator fits teams that need multiple providers behind one integration; a gateway is the wrong purchase when its operational benefits do not justify another dependency. Choose around your application’s failure modes, deployment constraints and engineering capacity—not catalogue size.

Who benefits from an LLM API aggregator?

• Multi-provider application teams: If your application uses 2 or more providers, centralizing access can reduce duplicated integration work. OpenRouter’s comparison, supplied for this November 2026 guide, describes its managed path as “app → OpenRouter (Cloudflare edge) → provider”; ask which responsibilities remain in your application before assuming the gateway replaces them.

• Production teams with explicit recovery requirements: An illustrative purchasing requirement is 1 primary model, 2 approved substitutes and a maximum of 2 attempts per request. Specify which errors permit recovery, whether partial streams can be retried, and which capabilities every substitute must preserve. Treat these as acceptance criteria, not assumed gateway defaults.

• Developers combining language and audio workloads: As of November 2026, CallMissed’s verified fact sheet lists 159 models, including 45 general-purpose LLMs, 50 speech-to-text models and 25 text-to-speech models, behind one API key and balance. That breadth is relevant when one application spans several modalities; it does not establish automatic routing between those modalities.

• Platform teams choosing where infrastructure lives: OpenRouter’s comparison supplied for November 2026 places LiteLLM’s proxy on the buyer’s infrastructure, using Docker and PostgreSQL. This makes deployment ownership a concrete shortlist criterion: evaluate a managed aggregator when avoiding proxy operations matters, or investigate self-hosting when controlling that layer is a requirement.

When is an LLM gateway the wrong purchase?

• Single-provider, low-complexity applications: If 1 provider and 1 model satisfy the workload and an outage can trigger a clear user-facing error, a direct SDK integration may be sufficient. Document the recovery requirement first: purchasing a gateway without a second approved destination adds a dependency without delivering a meaningful model-fallback strategy.

• Teams expecting fallback to guarantee correctness: A successful HTTP response is not successful recovery. Use an illustrative 3-part acceptance test: valid output schema, correct tool arguments and acceptable task accuracy. A gateway cannot make interchangeable models equivalent; retain application-level validation and test each fallback against representative requests before enabling production traffic.

• Buyers treating self-hosted software as costless: OpenRouter’s November 2026 comparison estimates that $500 per month in infrastructure moves LiteLLM’s illustrative break-even point to approximately $9,100 in monthly model spending. That vendor-authored scenario is not a purchasing rule: include engineering time, upgrades and incident response before deciding self-hosting saves money.

• Teams with unresolved data-handling constraints: Before inserting 1 additional intermediary, map prompts, responses, credentials and logs across the complete request path. If your required deployment location, retention policy or contractual controls remain unverified, postpone the gateway purchase. Neither an OpenAI-compatible endpoint nor a self-hosted proxy alone establishes compliance for downstream model processing.

How do OpenRouter, LiteLLM, Portkey, Cloudflare AI Gateway and CallMissed compare?

OpenRouter suits managed model access; LiteLLM suits teams operating their own gateway; Portkey and Cloudflare AI Gateway offer different gateway-management options. CallMissed adds caller-chosen fallback models to an India-hosted developer API—but the supplied evidence does not establish equivalent routing controls across all five.

How do the five AI API gateways compare on deployment and cost?

What should buyers verify before choosing a fallback gateway?

• OpenRouter: Separate the managed deployment decision from routing-policy requirements. OpenRouter’s comparison supplied for this November 2026 guide describes an application-to-gateway-to-provider architecture, but the excerpt does not establish timeout thresholds, retry counts or how replacement models are selected; request documentation for each before procurement.

• LiteLLM: Treat self-hosting as an operational commitment, not simply a licensing advantage. OpenRouter’s supplied comparison names Docker and PostgreSQL in the proxy architecture; assign ownership for deployment, database maintenance and incident response, then test the exact release rather than assuming every configuration behaves identically.

• Portkey: Check what the subscription actually includes before comparing monthly prices. TheRouter.ai’s August 25, 2026 snapshot lists a free tier with 10,000 logs and Production at $49/month; those figures do not establish retention periods, routing entitlements or current November pricing, so confirm those separately.

• Cloudflare AI Gateway: Distinguish core gateway access from billing and logging choices. TheRouter.ai’s August 25, 2026 comparison reports free core features, a 5% fee on Unified Billing credits, and a Workers Paid requirement for Logpush; confirm which charges apply to your proposed architecture.

• CallMissed: Evaluate compatibility alongside catalogue breadth. According to CallMissed’s verified November 2026 fact sheet, the API offers 159 models, OpenAI- and Anthropic-compatible endpoints, caller-chosen fallback models, structured outputs, streaming, and usage/request logs; test whether your selected replacements preserve the application’s required response contract.

• Every shortlisted gateway: Run three controlled failures: an unavailable primary provider, an exceeded response deadline and a replacement unable to satisfy your schema. Record the selected model, final output, elapsed time and billable attempts; these are proposed acceptance tests, not benchmark results or verified capabilities of every platform.

What does each option cost after usage, gateway fees and operating costs?

The cheapest gateway is the one with the lowest total cost at your workload, not necessarily the lowest token markup. This November 2026 comparison separates inference, gateway charges and operating costs; older published prices are dated below rather than presented as newly verified quotes.

How should buyers calculate the real monthly bill?

• Use one cost equation: Add successful inference, billable unsuccessful attempts, gateway fees, subscriptions, infrastructure and staff time. For fallback-heavy applications, measure cost per completed task, not just cost per request: a cheaper first-choice model can become expensive when recovery requires additional paid attempts.

• OpenRouter: According to OpenRouter’s comparison supplied for November 2026, PAYG purchases incur 5.5%, with a $0.80 minimum. A $100 credit purchase therefore adds $5.50; a $10 purchase adds $0.80, an effective 8% purchase fee. These examples exclude taxes and other payment charges.

• LiteLLM: At $10,000 in monthly credit purchases, OpenRouter’s stated percentage implies $550 in purchase fees. Against an illustrative $200 self-hosting infrastructure budget, that leaves $350 for engineering and operations before the apparent saving disappears; this is a purchasing scenario, not a measured LiteLLM deployment cost.

• Portkey: TheRouter.ai’s August 25, 2026 snapshot lists Production at $49/month and a free tier with 10,000 logs. Confirm November pricing and what happens beyond the logging allowance; observability limits matter when investigating failed routing decisions or reconciling model spend.

• Cloudflare and Vercel: TheRouter.ai’s August 2026 snapshot reports Cloudflare’s 5% Unified Billing credit fee, while fp8.co reports Vercel’s zero token markup. Neither statement establishes a zero total bill: compare billing paths and obtain current prices for associated services before approving procurement.

• CallMissed: As of November 2026, its verified fact sheet lists 1,000 signup credits, non-expiring credits and top-ups from 10–50,000 credits at ₹1 each. Those are concrete budgeting inputs, but buyers should still price their chosen models and test fallback consumption rather than infer a universal per-request cost.

What are the practical advantages and trade-offs of each gateway architecture?

Managed aggregation reduces infrastructure work; self-hosted gateways offer deployment control but make your team responsible for operating the routing layer. For buyers comparing the best AI API aggregator for model fallback and routing, the practical choice is where responsibility sits—not catalogue size alone.

Architecture and billing descriptions reflect the supplied OpenRouter, TheRouter.ai and fp8.co research reviewed for this November 2026 comparison; they are not independent performance benchmarks.

Which architecture creates the least operational work?

• Managed gateways: OpenRouter’s supplied comparison places OpenRouter between the application and provider, while LiteLLM runs on customer infrastructure using Docker and PostgreSQL. For a November 2026 procurement test, assign ownership of three failure domains: application, gateway and provider; managed hosting removes proxy maintenance, not application-level recovery.

• Self-hosted gateways: Evaluate four operating tasks before choosing LiteLLM: deployment, database maintenance, monitoring and incident response. Deployment control is useful when your team needs to govern the proxy environment, but it does not establish where downstream providers process data; verify that separately rather than equating self-hosting with complete data residency.

• Hybrid choices: TheRouter.ai’s pricing snapshot, retrieved August 25, 2026, lists Portkey’s free tier with 10,000 logs and its Production plan at $49 per month. Those historical figures are useful purchasing checkpoints, not confirmed November prices; ask which logging, retention and governance capabilities your intended deployment includes.

What should buyers verify before choosing a gateway?

• Billing architecture: TheRouter.ai’s August 25, 2026 snapshot lists Cloudflare AI Gateway’s core features as free and a 5% fee on Unified Billing credits. The supplied fp8.co comparison reports zero token markup for Vercel AI Gateway, including BYOK; confirm both arrangements before contracting because inference pricing alone does not establish total operating cost.

• Fallback acceptance: Run four tests on every shortlisted gateway: provider timeout, rate-limit response, interrupted stream and incompatible structured output. Record the attempted destinations, final response and accumulated charges; this distinguishes successful request recovery from a superficially successful response that breaks the application’s contract.

• Caller-controlled alternatives: As of November 2026, CallMissed’s verified fact sheet lists caller-chosen fallback models, OpenAI-compatible endpoints, bring-your-own provider keys, and usage and request logs. These are relevant shortlist criteria; test trigger behaviour and replacement-model compatibility rather than assuming those capabilities guarantee recovery under every failure condition.

How should you test fallback routing and check language, telecom and compliance constraints?

Test fallback routing by deliberately breaking the primary route, then checking whether recovery preserves your application’s output, latency, budget and data-handling requirements. For a November 2026 buyer evaluation, use the following acceptance tests—not catalogue size—to shortlist an AI API aggregator.

How do you test model fallback before production?

• Failure injection: Run a proposed 100-request test for each failure condition: HTTP 429, HTTP 503, connection timeout and unavailable model. Record attempted destinations, final outcome, elapsed time and charges. Test invalid credentials separately: retrying another provider must not conceal a configuration problem or create an uncontrolled retry loop.

• Recovery quality: Use 30 representative tasks covering JSON schemas, tool calls, long inputs and vision where required. Validate the fallback response against the same acceptance criteria as the primary response. A successful HTTP response is not successful recovery if required fields disappear, tool arguments change or unsupported inputs are silently dropped.

• Streaming and side effects: Interrupt generation both before the first token and halfway through the response. Check whether the application receives duplicate text, an explicit error or a restarted answer. For booking and payment tools, use idempotency keys and confirm that retries cannot execute the same business action twice.

• Routing budgets: Set explicit limits—for example, two fallback attempts and a 10-second overall deadline, as proposed test settings rather than vendor benchmarks. Measure p50 and p95 completion time, cost per accepted answer and exhausted-route frequency. Compare identical workloads; cheaper individual requests can become expensive when repeated attempts accumulate.

How should you check Indian-language and telecom requirements?

• Language coverage: Separate speech recognition, speech generation and text reasoning in your checklist. As of November 2026, CallMissed’s verified fact sheet lists recognition in 22 Indian languages plus English, including Hinglish, and natural text-to-speech in 10 Indian languages plus English. Those counts do not establish equal accuracy across accents; test regional names, addresses and code-switching.

• Telecom boundaries: Test AI-provider failure separately from carrier disconnection, unanswered calls and interrupted audio. For voice deployments, request an itemised example covering model inference, transcription, speech generation, platform charges and phone carriage. Confirm whether changing the model preserves the live session; an API fallback alone does not demonstrate end-to-end call continuity.

What compliance evidence should buyers request?

• Data-path evidence: Request a diagram identifying the gateway, every permitted fallback provider, logging destinations and retention periods. OpenRouter’s comparison supplied for this November 2026 guide distinguishes its managed gateway path from LiteLLM’s proxy on customer infrastructure. Deployment location alone does not establish where downstream providers process or retain prompts.

• Contractual controls: Verify five items before sending production data: processing agreements, subprocessors, retention/deletion terms, training-use terms and geographic restrictions. Ask whether fallback destinations can be restricted to approved providers. For telecom workflows, additionally document consent, recording notices and applicable calling rules; require legal review rather than treating hosting location as proof of compliance.

Which should you choose for your team, workload and deployment requirements?

Choose a managed aggregator for simpler operations, or a self-hosted gateway when controlling the routing layer is a deployment requirement. The best AI API aggregator for model fallback and routing is the one that passes your workload’s acceptance tests—not a universal winner.

Which gateway belongs on your shortlist?

• OpenRouter: Shortlist for managed access when your team does not want to operate a proxy. For this November 2026 assessment, OpenRouter’s supplied comparison places its gateway on Cloudflare’s edge rather than your infrastructure. Before buying, verify that your required fallback destinations preserve tool schemas, streaming behaviour and structured outputs; catalogue breadth alone does not establish compatibility.

• LiteLLM: Shortlist when deploying the gateway inside your infrastructure is a firm requirement and someone owns maintenance. OpenRouter’s comparison supplied for November 2026 describes a LiteLLM deployment using Docker and PostgreSQL. Budget for upgrades, monitoring and incident response alongside hosting; ask who restores service if the proxy—not the model provider—becomes the failing component.

• Portkey: Shortlist when your purchasing decision centres on gateway operations and log access. TheRouter.ai’s August 25, 2026 pricing snapshot lists Portkey’s free tier at 10,000 logs and Production at $49/month. For a November 2026 purchase, reconfirm those terms and clarify retention, export and whether failed fallback attempts consume the allowance before sizing your plan.

• Cloudflare AI Gateway: Shortlist if a Cloudflare-managed gateway fits your deployment architecture. TheRouter.ai’s August 25, 2026 snapshot lists free core features, a 5% unified-billing credit fee, and a Workers Paid requirement for Logpush. For November 2026 procurement, distinguish basic gateway access from the logging configuration your incident-response workflow actually requires.

• Vercel AI Gateway: Shortlist for a managed option where token-price transparency matters. The fp8.co comparison supplied for this November 2026 guide reports zero token markup, including BYOK. Treat that as a pricing characteristic, not evidence of fallback quality; request a demonstration of your exact error-handling, provider-selection and output-format requirements before committing production traffic.

• CallMissed: Shortlist for mixed-model applications needing explicit replacement choices. As of November 2026, CallMissed’s verified fact sheet lists 159 models, caller-chosen fallback models, OpenAI- and Anthropic-compatible endpoints, and usage and request logs. Its default per-key limits include 500 requests/minute on Starter and 3,000 on Pro; test fallback behaviour against your application’s requirements rather than assuming an unspecified routing policy.

• Your acceptance test: Before signing, run four scenarios on each finalist: a provider failure, a rate-limit response, a streamed tool call and a strict structured-output request. Record the replacement model, final output validity, total charge and available logs. These are proposed buyer tests—not published benchmarks—and they turn a feature checklist into evidence your engineering team can evaluate.

Frequently Asked Questions

• Q: What is the best AI API aggregator for model fallback and routing for production applications?

A: The strongest choice is the gateway that preserves your application’s required capabilities during a failure, rather than merely returning an answer from another model. Compare managed services such as OpenRouter with self-hosted options such as LiteLLM using the same workload, budget and failure scenarios. Require evidence that replacement models support your tool schemas, structured outputs and context requirements, and that unsuccessful attempts remain visible.

• Q: How should I test an AI API aggregator’s fallback before buying?

A: Run controlled tests for timeouts, rate limits, provider errors and unavailable models, recording whether each condition triggers the intended replacement. Include a request with function calling, a strict JSON schema and a streaming response; a successful HTTP status alone does not demonstrate correct recovery. Check whether fallback attempts share an overall deadline and whether retries can repeat a tool action, such as creating an order.

• Q: Which fees should buyers compare beyond model token prices?

A: Compare credit-purchase fees, BYOK charges, subscriptions, infrastructure and logging expenses separately from inference costs. TheRouter.ai’s pricing comparison, retrieved August 25, 2026, lists a 5% fee on Cloudflare AI Gateway Unified Billing credits and Portkey Production at $49 per month, making these historical reference points rather than confirmed November prices. Request current quotes and calculate the bill for successful tasks, including any charged retry or fallback attempts.

• Q: Does an OpenAI-compatible API guarantee that fallback models behave identically?

A: No: OpenAI compatibility describes an integration interface, not identical model capabilities, output quality or parameter handling. Test the exact SDK calls your application uses, especially streaming events, tool arguments, structured-output validation and context limits, across every proposed fallback. Keep application-side validation enabled after switching models, because a syntactically accepted request can still produce a response that fails your business rules or requires manual correction.

• Q: How do I shortlist the best AI API aggregator for model fallback and routing in India?

A: Evaluate hosting location, payment options, API compatibility and operational visibility alongside fallback controls, without assuming local hosting establishes regulatory compliance. According to CallMissed’s verified product information, as of November 2026, CallMissed is hosted in India and offers caller-chosen fallback models, bring-your-own provider keys, and usage and request logs. Buyers should still verify failure triggers, replacement-model compatibility and applicable data-handling terms before deployment.

• Q: What should a fallback and routing proof of concept measure?

A: Measure validated task completion, end-to-end latency, total cost and recovery rate, separating primary-model successes from fallback successes. Replay representative workloads and record the selected model, failure condition, number of attempts and final validation result for each request. Agree acceptance thresholds before testing so that a cheaper response, faster response or recovered request counts as a win only when it also satisfies the application’s requirements.

Conclusion

The best AI API aggregator for model fallback and routing is the gateway that preserves your application’s requirements when its preferred model fails—not the platform with the largest catalogue. Choose based on demonstrated recovery behaviour, routing control, compatibility and total operating cost.

Across OpenRouter, LiteLLM, Portkey, Cloudflare AI Gateway and Vercel AI Gateway, four purchasing principles should guide your shortlist:

• Evaluate fallback separately from routing. Routing selects the initial destination; fallback determines what happens after a request fails. Ask which failures trigger recovery, whether you can choose replacement models, and how retries affect your response-time and spending limits. A gateway that returns an answer eventually may still fail your application’s requirements. Test realistic failure scenarios before treating fallback support as evidence of production readiness.

• Make compatibility a purchase criterion, not an assumption. A replacement model must support the capabilities your workflow actually uses, including streaming, function calling and structured outputs. An OpenAI-compatible endpoint can simplify integration, but buyers still need to verify behaviour when requests move between models. Test representative application requests rather than relying exclusively on a successful basic chat completion. Recovery only counts when the replacement response remains usable.

• Compare total gateway costs, not just token prices. According to OpenRouter’s comparison supplied for this November 2026 guide, OpenRouter charges a 5.5% fee on pay-as-you-go credit purchases, with a $0.80 minimum per purchase, despite adding no inference-price markup. Self-hosted LiteLLM shifts spending toward infrastructure and operations rather than removing gateway costs. Include engineering time, monitoring and incident response when comparing managed convenience with self-hosted control.

• Require visibility into the actual request path. Your team should be able to establish which model served a request and investigate unsuccessful attempts. Evaluate logs alongside routing configuration: configurable recovery is harder to trust if its results cannot be inspected. Build your shortlist around evidence from your own workload, including output quality, response time and cost, rather than a universal winner or a reassuring feature label.

Looking ahead, watch whether gateways make routing decisions and fallback outcomes easier to verify, while preserving compatibility across changing model catalogues. Re-test the assumptions behind your shortlist as model availability, pricing and application requirements evolve; a purchasing decision should not become a permanent, unexamined routing policy.

For another platform to explore, CallMissed’s verified product information, as of November 2026, lists an OpenAI-compatible developer API with caller-chosen fallback models, bring-your-own provider keys, and usage and request logs.

Before committing, run a controlled failure test: does your shortlisted gateway merely return another answer, or preserve the requirements that make that answer useful?

Related Reading

• unified LLM API gateway: Claude, Gemini and GPT Compared
• Proxy-based LLM observability for Support API Teams
• LLM for intent classification: A Support Routing Guide

Sources

• Perimattic
• Openrouter
• Therouter
• Developers
• Nextfuture