Portkey Alternatives (2026): What to Use After the Palo Alto Networks Acquisition

Palo Alto Networks closed its acquisition of Portkey on May 29, 2026. The best Portkey alternatives depend on what you need: LiteLLM or Bifrost for self-hosting, Requesty for managed routing and spend controls, TrueFoundry for private enterprise deployment, Braintrust for evaluations, Cloudflare for managed routing, and OpenRouter for model access. We make Requesty, one of the products compared here.

Portkey alternatives at a glance

We organized this comparison around the job a Portkey user needs to keep doing, as of October 2026.

An inline check that blocks a request before it reaches a provider is different from a check that records a finding after the request has been sent. Test the action as well as the scanner.

What changed after the Portkey acquisition?

Palo Alto Networks announced its intent to acquire Portkey on April 30 and said it would continue to support existing and new customers after closing. The deal closed on May 29. Palo Alto subsequently announced general availability of Prisma AIRS AI Gateway in July.

Portkey's gateway license is MIT. Its gateway README distinguishes the open gateway from hosted and Enterprise functions, including prompt template management. In Enterprise hybrid deployment, the gateway and data plane run in the customer's environment while Portkey hosts the control plane. The model provider still receives the inference request.

A Portkey warning committed in August 2026 says Portkey no longer provisions new fully air-gapped Enterprise deployments; existing air-gapped deployments remain supported. If a new air-gapped installation is mandatory, get written deployment details from each candidate.

Ask Portkey for the renewal and support terms that apply to your agreement. If Prisma AIRS integration and your current Portkey controls meet your requirements, there is no need to move solely because ownership changed.

Seven alternatives, by use case

LiteLLM: for an operations team that wants an open proxy

Pick LiteLLM's self-hosted proxy when you want to run the gateway yourself. It has virtual keys, spend tracking, guardrails and load balancing. Its license places the enterprise directory under separate terms; the rest is MIT.

Its virtual-key setup requires PostgreSQL. Budget for the database, upgrades, secrets management and on-call work. LiteLLM's versioned prompt interface is marked Experimental.

Bifrost: for a Go gateway with a prompt repository

Pick Bifrost when you want an Apache 2.0 gateway with fallback, load balancing, governance, logs and tracing. Its open-source prompt repository and plugin support committed versions; Enterprise adds server-side weighted prompt deployments and advanced guardrails.

Now, the migration trap nobody mentions: Bifrost's plugin documentation says an unknown prompt ID or version logs a warning and lets the request proceed without injecting the template. Test an invalid ID and decide whether your application must reject it before calling the gateway.

Requesty: for managed routing and spend controls

We built Requesty for teams that want one managed endpoint for 600+ models, with fallback policies, application-facing API keys and spend limits. Create a caller key, attach the models it may use, and inspect usage by model, user or key. Our changelog documents routing policies, bring-your-own-key support, versioned prompts and PII and secrets scanners. Use access lists to attach an allowed model set to a caller key, then test allowed and denied requests before cutover.

When enabled, Requesty's guardrails scan inputs for personal information and secrets. Report records findings and forwards detected content unchanged. Mask replaces detected values before the provider receives the request; a finding does not itself block the request. Our October 22 guardrails documentation says the response step restores masked request values but does not scan for newly generated sensitive data. Retain a separate security layer for prompt-injection and harmful-output blocking.

Requesty enforces in-flight concurrency limits, not requests-per-minute limits. Use another enforcement layer if RPM is a requirement.

TrueFoundry: for enterprise deployment choices

Pick TrueFoundry when on-premise or VPC deployment is central to the purchase. Its AI Gateway connects model access with observability and governance.

TrueFoundry's September 19 documentation review said LLM output guardrails were skipped on streamed responses. Test streaming and non-streaming enforcement for your deployment, and map where its control plane, logs and provider calls run.

Braintrust: for traces that feed evaluations

Pick Braintrust when a gateway trace needs to become an evaluation. Its tooling lets you turn a trace into a dataset example and assess changes against a task and scorers. Braintrust also documents versioned prompts and evaluation playgrounds.

Ask about hosted service terms and test which failures are covered. Provider failover for the same model and fallback to a different model are separate requirements.

Cloudflare AI Gateway: for an existing Cloudflare stack

Pick Cloudflare AI Gateway if you already use Cloudflare and want managed provider keys, dashboard visibility and dynamic routes. Its guardrails announcement describes harmful-content checks on prompts, responses or both, with flag and block actions.

Price the logging path alongside inference. Cloudflare's October 15 pricing snapshot says accounts that created their first gateway on or after September 24, 2026 use Workers Logs pricing and retention. It also describes a 5% fee on Unified Billing credit purchases and separate Workers AI usage for guardrails.

OpenRouter: for hosted model access and provider selection

Pick OpenRouter when hosted access and provider selection are your main requirements. Callers can sort providers for a model by price, throughput or latency. Its Presets save system prompts, model settings and routing rules; its workspace guardrails include spending and access restrictions, injection defense and data-loss prevention.

Presets save shared configuration. Compare their prompt version history, approvals and variables with the workflow you use. Choosing a provider for one model also differs from failing over to a different model: the latter requires checking output quality and compatibility again.

If your team already operates Kong Gateway, pick Kong AI Gateway for evaluation: its AI Proxy connects a common interface to supported cloud and self-hosted models. Helicone announced in March 2026 that its platform was moving into maintenance mode. Confirm its current roadmap before adopting it.

Map the Portkey features before switching

Credentials and model IDs

An application-facing gateway key identifies the caller. A provider credential authorizes the gateway to call the model provider. Inventory both, including their owners, allowed models and spend limits.

Portkey moved Virtual Keys into Model Catalog, where provider credentials and model access are managed centrally. Inventory older virtual-key integrations as well as Model Catalog provider entries before creating new caller keys. Portkey's API specification documents model identifiers in the @provider-slug/deployment-name form. Map the destination model ID, provider credential and region explicitly.

For Requesty, create a new caller key and add supported provider credentials through bring your own keys when you want to use your provider account. A September 24 Requesty BYOK snapshot states a maximum of one key per provider. Account for this when teams or environments need separate provider accounts.

Create access lists for caller keys and configure Approved Models for the organization. Test each caller key with an allowed model and a model it must not access before shifting traffic.

Prompt versions and parameters

A prompt is more than its text. Record the production version, template variables, attached model, parameters and output format. In Portkey's prompt versioning documentation, a prompt ID with no suffix uses the published version. @latest selects the most recent version, including an unpublished one; @12 selects version 12. Record the published version before migrating and verify how the destination selects a version.

Requesty's Prompt Library supports prompt versions, diffs and variables. LiteLLM's experimental prompt manager uses the latest version by default and accepts a specific version. Bifrost's plugin uses the latest committed version when no version header or matching Enterprise deployment selects another version. A matching deployment overrides the version header. Request parameters override saved model parameters.

In Requesty, settings saved on the prompt override matching request fields, including temperature and response format. Compare the effective provider-bound parameters before cutover.

Render the same variables on both systems and compare the provider-bound messages. Change a draft prompt in a test environment and confirm production still resolves to the intended version.

Guardrails and caching

For each Portkey check, write down what it detects, whether it inspects input or output, whether it blocks or records, and whether the check finishes before the provider receives the request. Portkey's August guardrails documentation says checks evaluate the last message in the request. Portkey describes synchronous checks for enforcement and asynchronous checks for observation. For streamed responses, its output guardrails run after the stream completes and the results are informational; they do not block output or trigger fallback or retry. Test your endpoint, message scope and action.

Cache behavior needs the same care. Portkey documents response caching, including semantic caching. Its August cache documentation says semantic caching requires a vector database and is available on select Enterprise plans, while its feature comparison lists it under Pro and Enterprise. Confirm the feature in your contract.

Portkey's current cache documentation also says semantic matching ignores the system prompt. In a test environment, change the system prompt, repeat a semantically similar request and inspect the cache result before relying on a prompt update. The same behavior is described in the August snapshot linked above.

Requesty's Auto Caching uses provider-side prompt caching: the request still goes to the provider. If your application depends on returning a stored response, preserve that behavior separately and review its retention rules.

Logs and data location

Export what your retention policy requires before retiring a Portkey account. Portkey's August export documentation describes log export as an Enterprise feature, in JSONL, with up to 50,000 logs per job. Divide larger exports into jobs before the retention window closes. Historical logs can live in an approved archive outside the new gateway.

Portkey's August logs page listed 10,000 logs per month and three-day retention for Developer. Portkey's Production pricing lists 100,000 recorded logs per month and a $9 overage per additional 100,000 requests, with 30-day log retention. Its separate Pro feature comparison describes the $9 increment up to 3 million requests. Confirm the billable counter and high-volume terms for your plan.

A regional gateway endpoint and a regional model deployment are separate choices. For Requesty, select the EU gateway endpoint, then choose model deployments that meet your inference-location requirements. Check where logs, backups and support access sit as well. Our two-layer guide explains the distinction.

Migrate without losing controls

1. 1
   Inventory one production workflow

   List its client endpoint, gateway and provider keys, model IDs, routing config, prompt versions, guardrails, cache, log destinations and regions. Name the owner of each item. Start with one workflow whose output your team can assess.

2. 2
   Recreate access and routing

   Create new caller keys and model allowlists. Add supported provider credentials, then configure the primary route and its backups. Compare error triggers, retry counts and timeouts with the old configuration. Portkey's default fallback triggers on non-2xx responses; on_status_codes can restrict the trigger. Test the destination policy against the status codes your Portkey config uses. Our guide to 429 errors helps distinguish provider rate limits from other failures. Make sure every fallback model supports the required tools, output format and data location.

3. 3
   Rebuild prompts, safety and telemetry

   Copy the released prompt and its settings, establish the destination version-selection rule, and recreate the required input and output checks. Verify cost attribution, redaction, retention and export access. Keep existing response-cache behavior where the application depends on it.

4. 4
   Replay and compare

   Use approved synthetic or sanitized requests. Compare rendered prompts, tool calls, structured output, streaming, latency, cost and error behavior. Force a provider failure in a test environment and confirm which fallback ran. Inspect both the provider-bound request and the caller-facing response.

5. 5
   Shift traffic and keep a rollback path

   Move a controlled portion of traffic after the tests pass. Monitor errors, spend, guardrail outcomes and missing logs. Keep the old route and credentials available until the new route meets your acceptance criteria, then archive required history and retire the old credentials.

A fallback can change the model, the provider or both. That affects cost and can change the response format or tool behavior. Test the downstream application against every model in the chain, including the primary route. Our load-balancing documentation covers distributing traffic across providers.

Try the managed route with Requesty

Create a Requesty account, create an API key and add credits for the paid model below. Install the OpenAI Python SDK with pip install openai. Export your Requesty key with export REQUESTY_API_KEY='your-key', then run this example based on the Requesty quickstart:

import os
from openai import OpenAI
 
client = OpenAI(
    api_key=os.environ["REQUESTY_API_KEY"],
    base_url="https://router.requesty.ai/v1",
)
 
response = client.chat.completions.create(
    model="openai/gpt-6-luna",
    messages=[{"role": "user", "content": "Summarize this request."}],
)
print(response.choices[0].message.content)

To test fallback, create a policy named production-fallback with your approved models in the routing policy editor. Then replace the model string with policy/production-fallback. The fallback guide covers model order and retries. Remove Portkey-specific configuration after its controls have replacements and the pilot passes. Our guide to OpenAI-compatible APIs covers client compatibility.

Compare the bill and make the decision

A fee on purchased credits, a charge per request and a per-seat fee use different bases. Include model inference, cached tokens, guardrail scans, log retention, seats and infrastructure in the same monthly estimate.

Assume you buy $10,000 in Requesty prepaid credits and use them for model inference. The top-up fee is $10,000 × 0.05 = $500, so you pay $10,500 for $10,000 in credits. The fee is charged once on the top-up. Guardrail scans can add charges, and BYOK terms need a separate quote. The October 22 billing snapshot describes the top-up mechanism.

Which alternative should you pick?

For harmful-content flagging or blocking on prompts and responses, pick Cloudflare. For prompt-injection checks, evaluate OpenRouter's workspace controls or LiteLLM's integrations, and test their enforcement and streaming behavior. If observability feeds model evaluations, pick Braintrust. If virtual keys and spend controls are the priority, pick Requesty for a managed gateway or LiteLLM for self-hosting. If prompt management is central, pick Bifrost for its self-hosted repository or Braintrust for prompts tied to evaluations. Stay with Portkey if its controls and Prisma AIRS fit your requirements.

This week, inventory one production workflow: record its caller key, published prompt, guardrails and fallback chain. Then replay it against your chosen gateway with synthetic data. For a managed pilot, start with the Requesty fallback guide.