Cloudflare vs Vercel AI Gateway

TL;DR: choose by platform gravity, then prove it with your traffic

What this comparison must help you decide

People searching “Cloudflare vs Vercel AI Gateway” usually already understand the category. They need to know which gateway fits their stack, whether current APIs are compatible, how routing and caching actually behave, what gets logged, how costs are composed, and whether migration is reversible. Marketing summaries do not answer those questions; an executable decision contract does.

Who this guide is for and prerequisites

This guide is for teams moving from direct provider calls, standardizing several model vendors, or choosing a gateway for an AI application already deployed on Cloudflare or Vercel.

• One representative model and one fallback model with access confirmed on both candidates.
• A fixed prompt set containing short, long, streaming, tool-call, structured-output, and safety-sensitive cases.
• Server-side secrets, a request ID, tenant identity, timeout budget, and a redaction policy.
• Success thresholds for p95 latency, error rate, fallback rate, output validity, and cost per accepted response.

Decision matrix: when each gateway is the stronger default

Architecture: keep gateway policy out of business logic

Cloudflare vs Vercel AI Gateway: current capability comparison

Step-by-step implementation with the same client contract

Start with the OpenAI client because both gateways document compatible chat completion paths. Discover and pin a model available in your account; model catalogs change, so the example intentionally uses an environment variable rather than a hard-coded “latest” model.

import OpenAI from "openai";

type Gateway = "cloudflare" | "vercel";

const profiles = {
  cloudflare: {
    apiKey: process.env.CLOUDFLARE_API_TOKEN!,
    baseURL:
      "https://api.cloudflare.com/client/v4/accounts/" +
      process.env.CLOUDFLARE_ACCOUNT_ID + "/ai/v1",
    model: process.env.CLOUDFLARE_MODEL_ID!,
  },
  vercel: {
    apiKey: process.env.AI_GATEWAY_API_KEY!,
    baseURL: "https://ai-gateway.vercel.sh/v1",
    model: process.env.VERCEL_MODEL_ID!,
  },
} satisfies Record<Gateway, {
  apiKey: string; baseURL: string; model: string;
}>;

export async function runGateway(gateway: Gateway, prompt: string) {
  const profile = profiles[gateway];
  const client = new OpenAI({
    apiKey: profile.apiKey,
    baseURL: profile.baseURL,
    timeout: 30_000,
    maxRetries: 0, // own retries once; avoid retry multiplication
  });

  const started = performance.now();
  const response = await client.chat.completions.create({
    model: profile.model,
    messages: [{ role: "user", content: prompt }],
    temperature: 0,
  });

  return {
    gateway,
    model: response.model,
    text: response.choices[0]?.message?.content ?? "",
    usage: response.usage,
    durationMs: Math.round(performance.now() - started),
  };
}

For Cloudflare’s REST API, the account token authenticates the call and third-party models use author/model naming. Provider-specific Cloudflare endpoints use different credential/header patterns, so choose one path and document it. For Vercel, query the model catalog before pinning an ID.

curl "https://ai-gateway.vercel.sh/v1/models" \
  -H "Authorization: Bearer $AI_GATEWAY_API_KEY" \
  -H "Content-Type: application/json"

# Store the reviewed creator/model ID in VERCEL_MODEL_ID.
# Re-run discovery during planned model upgrades, not per request.

Routing and fallback: make failure semantics explicit

Caching: optimize only requests that are semantically reusable

Cloudflare documents an exact-match cache key that includes provider, endpoint, model, provider authorization header, and full request body. That makes repeated deterministic calls a natural candidate, but identity, tool state, retrieval freshness, and authorization can make two text-identical prompts semantically different.

• Cache classification, extraction, and static transformations when inputs are complete and deterministic.
• Do not cache user-private conversations, permission-dependent answers, live balances, or tool results without an explicit identity and freshness key.
• Measure accepted-answer cache hit rate, not raw cache hit rate.
• Define bypass and purge procedures before enabling cache in production.

Logging, privacy, and observability controls

Cloudflare logging is enabled by default and can include prompts and model responses. Its current docs specify cf-aig-collect-log: false to skip the log and cf-aig-collect-log-payload: false to keep metadata without request and response bodies. Treat these as implementation controls, not a complete privacy program.

A same-workload validation plan

Run both gateways against the same accepted-answer contract. Use at least three regions, cold and warm periods, streaming and non-streaming requests, concurrency ramps, and forced provider failures. Keep the model and provider fixed for baseline latency; test routing policy separately.

type Run = {
  ok: boolean;
  schemaValid: boolean;
  policyAllowed: boolean;
  durationMs: number;
  attempts: number;
  costUsd?: number;
};

export function summarize(runs: Run[]) {
  const accepted = runs.filter(
    (r) => r.ok && r.schemaValid && r.policyAllowed
  );
  return {
    requests: runs.length,
    acceptedRate: accepted.length / runs.length,
    retryAmplification:
      runs.reduce((n, r) => n + r.attempts, 0) / runs.length,
    costPerAccepted:
      runs.reduce((n, r) => n + (r.costUsd ?? 0), 0) /
      Math.max(accepted.length, 1),
  };
}

Cost model: compare total accepted-output cost

Gateway pricing changes, so verify the current plan pages before purchase. The durable comparison is an equation: provider inference + gateway or credit fees + retries and fallbacks + log storage/export + application compute + engineering operations, divided by accepted business results.

Common failure modes and fixes

Migration and rollback plan

• Rollback if accepted success rate drops, p95 exceeds budget, retry amplification rises, or trace completeness falls.
• Keep old credentials and dashboards active through the observation window.
• Freeze routing policy during benchmark runs; otherwise you are comparing changing systems.

Where QVeris fits: capability layer, not model gateway replacement

Cloudflare or Vercel can govern traffic between your application and model providers. QVeris complements that layer when an agent also needs external APIs and tools. The pattern is Discover → Inspect → Call: find a capability, inspect schema and permissions, then invoke it with bounded inputs. Keep model-routing evidence from the gateway and tool-source evidence from QVeris as separate provenance chains.

Cloudflare vs Vercel AI Gateway FAQ

Official sources

Gateway APIs, model catalogs, pricing, and plan limits change. These primary sources were checked for this July 2026 revision; verify them again before production rollout.