---
title: "OpenRouter vs Portkey (2026): AI Gateways Compared - API7.ai"
description: "OpenRouter vs Portkey compared: model coverage, routing, caching, guardrails, budgets, MCP, self-hosting, and pricing — and how to choose."
url: "https://api7.ai/openrouter-vs-portkey"
---

# OpenRouter vs Portkey: Which AI Gateway in 2026?

By API7.ai Team

Last updated: June 2026

OpenRouter and Portkey both put one API in front of many LLM providers, but they take different shapes: a fully hosted model marketplace versus an open-source gateway paired with a hosted governance platform. This guide compares them on model coverage, routing, caching, guardrails, budgets, MCP, self-hosting, and pricing so you can choose the right fit.

TL;DR

OpenRouter is a zero-ops hosted marketplace: 400+ models behind one key, billed via credits or BYOK, with provider and uptime-based routing. Portkey is an open-source TypeScript gateway plus a hosted governance platform, adding native guardrails, semantic caching, and an MCP gateway. The choice comes down to a zero-ops marketplace versus a self-hostable gateway with deeper governance.

- Teams wanting zero-ops access to many models: OpenRouter
- Teams wanting a self-hostable gateway + governance: Portkey

<!---->

- [At a glance](#at-a-glance)
- [What is OpenRouter?](#what-is-openrouter)
- [What is Portkey?](#what-is-portkey)
- [Feature comparison](#feature-comparison)
- [Pricing](#pricing)
- [When to use each](#choose)
- [Bottom line](#bottom-line)
- [FAQ](#faq)

## OpenRouter vs Portkey at a glance

OpenRouter is a hosted-only marketplace for 400+ models with provider and uptime routing; Portkey is a self-hostable OSS gateway plus a hosted platform that adds native guardrails and an MCP gateway. Neither offers semantic routing or ensemble.

| Dimension           | OpenRouter                          | Portkey                                   |
| ------------------- | ----------------------------------- | ----------------------------------------- |
| Best for            | Zero-ops hosted marketplace         | OSS gateway + hosted governance           |
| Core & runtime      | Proprietary hosted SaaS             | TypeScript gateway + hosted control plane |
| Open-source license | — Proprietary; not open source      | MIT gateway; platform commercial          |
| Model coverage      | 400+ models                         | 1,600+ models / 45+ providers             |
| Semantic routing    | — Provider/uptime routing only      | — Rule-based only                         |
| Ensemble / fusion   | — Not documented                    | — Not documented                          |
| Caching             | ✓ Response + prompt caching         | ✓ Simple + semantic                       |
| Content guardrails  | — Not offered                       | ✓ 20+ native + LLM/partner                |
| MCP gateway         | — Not a native feature              | ✓ Documented                              |
| Self-host / VPC     | — Hosted only                       | OSS self-host; VPC = Enterprise           |
| SSO / SCIM          | SSO Enterprise; SCIM not documented | Enterprise-only                           |

## What is OpenRouter?

OpenRouter is a proprietary, fully hosted marketplace that puts 400+ models behind one API and key, with provider routing, fallbacks, and uptime-based load balancing, billed via credits or your own keys.

OpenRouter is a proprietary, fully hosted marketplace that puts 400+ models behind one API and key. It handles provider routing, fallbacks, and uptime-based load balancing, and bills through credits or your own provider keys (BYOK). It is not self-hostable or open source.

Runtime

Hosted SaaS (proprietary)

License

Proprietary; not open source

Form factor

Hosted marketplace + API

Best for

Zero-ops access to many models

### Pros

- 400+ models through one key with zero operations
- Provider routing, fallbacks, and uptime-based load balancing
- Credits (no inference markup) or BYOK
- Response Caching (beta) plus prompt-caching passthrough

### Cons

- Not self-hostable and not open source
- No content-moderation or PII guardrails; no MCP gateway
- Auto Router relies on a third-party model, not intent routing

## What is Portkey?

Portkey is an AI gateway pairing an open-source TypeScript gateway with a paid hosted control plane for observability, prompt management, and governance, plus native guardrails and an MCP gateway.

Portkey is an AI gateway that pairs an open-source TypeScript gateway (MIT) with a hosted control plane for observability, prompt management, and governance. It advertises 1,600+ models across 45+ providers and adds native guardrails and an MCP gateway.

Language

TypeScript (Node.js)

License

MIT gateway + commercial platform

Form factor

OSS gateway + hosted SaaS

Best for

Self-hostable gateway + governance

### Pros

- 1,600+ models across 45+ providers
- Native guardrails (20+) plus a documented MCP gateway
- Simple and semantic caching (semantic on Enterprise)
- OSS gateway self-hosts via Docker/Kubernetes

### Cons

- RBAC (Production tier), SSO/SCIM, VPC deploy, granular budgets are paid
- Conditional routing is rule/parameter-based, not semantic
- No documented ensemble; log/metric retention is tiered by plan

## OpenRouter vs Portkey: feature comparison

The two converge on multi-provider access, routing basics, caching, and budgets, then diverge on form factor (hosted-only marketplace vs self-hostable OSS gateway) and on native guardrails and an MCP gateway, which Portkey has and OpenRouter does not.

| Feature              | OpenRouter                                                                                                                             | Portkey                                                                                         |
| -------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
| Core & runtime       | Proprietary, fully hosted SaaS; not self-hostable and not open source                                                                  | Open-source TypeScript gateway (Node.js) + a separate hosted control plane                      |
| Model coverage       | 400+ models through one API and key                                                                                                    | 1,600+ models across 45+ providers                                                              |
| Routing              | Provider routing + fallbacks + uptime-based load balancing (sort by price/throughput/latency); Auto Router uses third-party NotDiamond | Load balancing, fallbacks, retries, conditional routing (metadata/params/path), circuit breaker |
| Semantic routing     | — Provider/uptime routing, not intent-based                                                                                            | — Rule/parameter-based only                                                                     |
| Ensemble / fusion    | — Not documented                                                                                                                       | — Not documented                                                                                |
| Caching              | Native Response Caching (beta) + Prompt Caching passthrough                                                                            | Simple + semantic caching (semantic is Enterprise-tier)                                         |
| Guardrails           | No content-moderation/PII feature; "Guardrails" = spending limits, model/provider allowlists, Zero Data Retention                      | 20+ deterministic + LLM-based + partner checks; tiered                                          |
| Observability        | Unified Reporting and Traces                                                                                                           | Logging, tracing, 21+ metric dashboard, OpenTelemetry; retention tiered                         |
| Budgets & governance | Per-key credit limits + Unified Reporting + Traces                                                                                     | Model Catalog: cost/token budgets, rate limits, workspaces — granular budgets Enterprise        |
| MCP gateway          | — Not a native feature                                                                                                                 | ✓ Documented (auth + access control for remote MCP)                                             |
| Self-host / VPC      | — Hosted only; not self-hostable                                                                                                       | OSS self-hosts; managed VPC/hybrid is Enterprise                                                |
| Enterprise identity  | SSO (SAML) Enterprise; Admin/Member roles; SCIM not documented                                                                         | RBAC from Production tier; SSO/SAML/OIDC & SCIM Enterprise                                      |

## Pricing comparison

OpenRouter charges a fee on credits (or a BYOK fee) with no inference markup; Portkey's gateway is free and open source, with governance features paywalled by tier.

OpenRouter has no inference markup: you pay for model usage at provider rates. It charges 5.5% on credit purchases (with a $0.80 minimum); bring-your-own-key requests are free for the first 1,000,000 per month, then 5%. Portkey's gateway is free (MIT); the hosted platform is tiered — a free Developer tier with capped logs, a paid Production tier (from about $49/month) that unlocks RBAC and service accounts, and an Enterprise tier for SSO/SCIM, VPC/hybrid deployment, granular budgets, semantic caching, and custom retention. In short, OpenRouter monetizes credits and BYOK on a hosted marketplace, while Portkey gives away the gateway and gates platform governance by tier.

## When to use OpenRouter vs Portkey

Choose OpenRouter for zero-ops access to many models via one key; choose Portkey for a self-hostable gateway with native guardrails, an MCP gateway, and a hosted governance UI.

### Choose OpenRouter if you…

- Want zero-ops access to 400+ models behind one key
- Prefer credit-based billing or bringing your own provider keys
- Do not need self-hosting, native guardrails, or an MCP gateway

### Choose Portkey if you…

- Want a self-hostable open-source gateway you can run yourself
- Need native content guardrails and an MCP gateway
- Want a hosted observability, analytics, and prompt-management UI

## Bottom line

Choose OpenRouter for zero-ops breadth across 400+ models; choose Portkey for a self-hostable OSS gateway with native guardrails and an MCP gateway.

For zero-ops access to 400+ models behind one key — billed via credits or your own provider keys — OpenRouter is the simpler pick; for a self-hostable open-source gateway with native guardrails, an MCP gateway, and a hosted governance UI, Portkey fits better. If you're evaluating open-source AI gateways more broadly, AISIX is another option worth a look: a Rust, Apache-2.0 gateway from the creators of Apache APISIX, with semantic routing and ensemble built into the open-source core and self-hosting in your own VPC. See [all AI gateway comparisons](https://api7.ai/ai-gateway-comparison) or [AISIX vs LiteLLM](https://api7.ai/aisix-vs-litellm).

## Frequently asked questions

### Is OpenRouter or Portkey better?

It depends on what you want to run. OpenRouter is a fully hosted marketplace that puts 400+ models behind one key with zero operations, billed via credits or your own keys. Portkey pairs an open-source TypeScript gateway with a hosted control plane and adds native guardrails, semantic caching, and an MCP gateway. Pick OpenRouter for zero-ops breadth; pick Portkey for a self-hostable gateway with deeper governance.

### Is OpenRouter open source?

No. OpenRouter is a proprietary, fully hosted SaaS. It is not self-hostable and its gateway is not open source; you access its 400+ models through its API and credits or your own provider keys (BYOK).

### Is Portkey open source?

Partly. Portkey's AI Gateway is open source under the MIT license and is written in TypeScript, and it can be self-hosted via Docker or Kubernetes. The hosted platform that adds observability, prompt management, RBAC, SSO/SCIM, and VPC deployment is commercial and tiered.

### Do OpenRouter or Portkey support semantic routing?

Neither routes by the meaning of a request. OpenRouter offers provider routing with fallbacks and uptime-based load balancing, sortable by price, throughput, or latency; its Auto Router uses a third-party model (NotDiamond) and is not intent-based. Portkey offers rule- and parameter-based conditional routing. Routing by request meaning, or ensemble (fan-out and synthesize), is not a documented feature of either.

### Do OpenRouter and Portkey offer content guardrails?

It differs. Portkey ships native guardrails — 20+ deterministic checks plus LLM-based and partner checks (tiered). OpenRouter does not offer a content-moderation or PII feature; what it labels "Guardrails" is spending limits, model/provider allowlists, and Zero Data Retention, not content filtering.

### What are some alternatives to OpenRouter and Portkey?

The AI gateway space also includes LiteLLM, Kong AI Gateway, and AISIX, among others. AISIX, for example, is a Rust-native gateway whose entire data plane is Apache-2.0, built by the creators of Apache APISIX, with semantic routing and ensemble in the open-source core and self-hosting in your own VPC. Which one fits depends on whether you want a hosted marketplace, a hosted governance platform, or a fully open self-hosted data plane.

## Related comparisons

[Portkey vs LiteLLM](https://api7.ai/portkey-vs-litellm) · [AISIX vs LiteLLM](https://api7.ai/aisix-vs-litellm) · [All AI gateway comparisons](https://api7.ai/ai-gateway-comparison)

## Ready to get started?

For more information about full API lifecycle management, please contact us to Meet with our API Experts.

[Contact Us](https://api7.ai/contact)
