AI

Everything below is one of these three. Pick by what you need: simplest default, a specific model with no key, or your own vendor account.

• Purpose method, env.AI.chat / research / code / vision / image / embed / …. The included Cloudflare-hosted models, picked for you per task. No key, metered to your AI credits, and we can upgrade the model behind a purpose without you changing code.
• Run by id, env.AI.run("<id>", input). Run a specific model Cloudflare serves, by its id, still no key and metered to your AI credits. That covers every Workers AI model ("@cf/…"), the included clean names, and OpenAI / Anthropic / Google models by full id (e.g. "openai/gpt-6-luna").
• Bring your own key, env.AI.openai / anthropic / google / jev. Set that vendor's key as an app env var and the call goes straight to the vendor on your account, Cloudrizz never sees the key and bills nothing.

// api/ai.js — a minimal included-model call, no key
export default {
  async fetch(request, env) {
    const { question } = await request.json();
    const res = await env.AI.chat({ messages: [{ role: "user", content: question }] });
    return Response.json({ answer: res.response });   // res.response is the text
  },
};

The simplest way to add AI: no key, nothing to attach, metered to your plan's AI credits (every plan includes a monthly grant; top up for more). Each method takes the input in the table below and returns a fixed shape, so you always know where the answer is.

// api/assistant.js
export default {
  async fetch(request, env) {
    const { question, ticket } = await request.json();

    const reply    = await env.AI.chat({ messages: [{ role: "user", content: question }] });
    const analysis = await env.AI.research({ messages: [{ role: "user", content: "Analyse: " + question }] });
    const vec      = await env.AI.embed({ text: question });
    const picture  = await env.AI.image({ prompt: question });

    // Typed decision — branchable output, no prose to parse:
    const decision = await env.AI.decide({
      state: ticket,
      questions: {
        urgent: { type: "noul", instructions: "Is this time-sensitive?" },
        team:   { type: "choice", instructions: "Which team?", criteria: { billing: "Payments", technical: "Bugs" } },
      },
    });

    return Response.json({
      reply: reply.response,                       // text
      firstVector: vec.data[0],                    // embeddings
      urgentProb: decision.answers.urgent.noul,    // 0..1
      team: decision.answers.team.choice,          // "technical"
    });
  },
};

Every purpose method, its input, and where to read the result:

Pin a specific included model instead of a purpose by passing its clean name to env.AI.run, e.g. env.AI.run("llama-3.3-70b", { messages }). The full catalogue:

env.AI.run("<id>", input) runs a specific model Cloudflare serves, with no API key, metered to your AI credits, exactly like the included models. That includes OpenAI, Anthropic, and Google models by their full provider id (openai/…, anthropic/…, google/…). Cloudrizz routes each to the right endpoint server-side, you just pass the provider's native request shape.

Using gpt-6-luna (an OpenAI Responses model) in a user app. Pass input (a string), an optional max_output_tokens, and an optional reasoning.effort (low / medium / high). The reply is OpenAI's Responses shape, the text lives under output:

// api/luna.js — gpt-6-luna, no key, billed to your AI credits
export default {
  async fetch(request, env) {
    const { question } = await request.json();

    const res = await env.AI.run("openai/gpt-6-luna", {
      input: question,
      max_output_tokens: 512,
      reasoning: { effort: "low" },     // optional: low | medium | high
    });

    // Responses shape — pull the assistant text out of output[]:
    const text = res.output
      ?.find((o) => o.type === "message")
      ?.content?.find((c) => c.type === "output_text")?.text ?? "";

    return Response.json({ answer: text, usage: res.usage });
  },
};

Chat-shaped models (most OpenAI + all Google) take messages and return the familiar chat-completion shape; Anthropic needs max_tokens and returns its own shape:

// OpenAI / Google chat — read choices[0].message.content
const gpt = await env.AI.run("openai/gpt-5", {
  messages: [{ role: "user", content: question }],
});
const gptText = gpt.choices[0].message.content;

const gem = await env.AI.run("google/gemini-2.5-pro", {
  messages: [{ role: "user", content: question }],
});
const gemText = gem.choices[0].message.content;

// Anthropic — max_tokens is required; read content[0].text
const claude = await env.AI.run("anthropic/claude-sonnet-4.5", {
  messages: [{ role: "user", content: question }],
  max_tokens: 1024,
});
const claudeText = claude.content[0].text;

Verified available (call any by full id): OpenAI gpt-4.1 / gpt-4.1-mini / gpt-4.1-nano, gpt-4o / gpt-4o-mini, gpt-5 / gpt-5-mini / gpt-5-nano, o3, o4-mini, gpt-6-luna; Anthropic claude-haiku-4.5 / claude-sonnet-4.5 / claude-opus-4.5 / claude-sonnet-5 / claude-opus-5; Google gemini-2.5-flash / gemini-2.5-pro / gemini-2.5-flash-lite / gemini-3-flash. Other models Cloudflare serves work the same way, prefix with the provider name.

env.AI also generates images, video, and music, one recommended model per task, no key. These are metered by output unit (per image, or per second of video/audio), so a longer clip costs more. They return JSON with a signed URL to the file (res.result.video / .audio / .image), not raw bytes; the models that edit an existing asset take a URL (host it in env.STORAGE and pass its link).

// api/clip.js — a short video from a prompt (billed per second)
export default {
  async fetch(request, env) {
    const { prompt } = await request.json();
    const res = await env.AI.video({ prompt });
    // res.result.video is a signed URL (valid ~24h) — download + re-store it
    // in env.STORAGE if you need it to persist.
    return Response.json({ url: res.result.video });
  },
};

// Music: duration is in MILLISECONDS
const song = await env.AI.music({ prompt: "calm lofi loop", music_length_ms: 15000 });
// song.result.audio → signed URL

// Text → image returns base64 (not a URL):
const pic = await env.AI.image({ prompt: "a red bicycle" });
return new Response(Uint8Array.from(atob(pic.image), (c) => c.charCodeAt(0)), {
  headers: { "content-type": "image/png" },
});

Two methods give a model access to the live internet, so your app isn't stuck at a model's training cutoff. Both are included (no key, metered to your AI credits) and run on Cloudflare: env.AI.search returns ranked web results, env.AI.browse reads a page's text.

The classic pattern is search, then browse the best hits, then answer (a live-web RAG loop), all with no key:

// api/ask-web.js — answer a question from fresh web results
export default {
  async fetch(request, env) {
    const { question } = await request.json();

    // 1) Search the live web (ranked results).
    const { items } = await env.AI.search({ query: question, limit: 5 });

    // 2) Read the top couple of pages for their actual text.
    const pages = await Promise.all(
      items.slice(0, 2).map((r) => env.AI.browse(r.url).catch(() => null)),
    );
    const context = pages
      .filter(Boolean)
      .map((p) => p.title + "\n" + p.text)
      .join("\n\n---\n\n");

    // 3) Answer grounded in what you just fetched, with citations.
    const res = await env.AI.chat({
      messages: [
        { role: "user", content:
          "Using these web sources, answer: " + question +
          "\n\nSources:\n" + context +
          "\n\nCite the source URLs you used." },
      ],
    });
    return Response.json({ answer: res.response, sources: items.map((i) => i.url) });
  },
};

For a live “typing” chat, pass stream: true (purpose methods) or use .stream(...) (BYO). You get a Response whose body is a Server-Sent-Events stream, pipe it straight to the browser and render tokens as they arrive.

// api/chat.js — stream an included-model reply to the browser
export default {
  async fetch(request, env) {
    const { messages } = await request.json();
    const res = await env.AI.chat({ messages, stream: true });
    return new Response(res.body, {
      headers: { "content-type": "text/event-stream; charset=utf-8" },
    });
  },
};

On the client, read it with EventSource (or fetch + a stream reader) and append each delta. With your own key, env.AI.openai.stream(...) / env.AI.anthropic.stream(...) / env.AI.google.stream(...) stream direct from the vendor.

To make a model answer from your app's content, pair it with env.SEARCH. Retrieve the most relevant passages by meaning, put them in the prompt, then stream the answer, no key needed:

const { matches } = await env.SEARCH.query(question, { topK: 6 });
const context = matches.map((m) => m.text).join("\n---\n");
const res = await env.AI.chat({
  stream: true,
  messages: [{ role: "user", content: `Context:\n${context}\n\nQuestion: ${question}` }],
});
return new Response(res.body, { headers: { "content-type": "text/event-stream" } });

When you want a decision your code can branch on (not prose), env.AI.decide (included, no key) and env.AI.jev (bring-your-own TypeSafe key) both take state plus typed questions and return typed answers with calibrated probabilities, in one call. No prompt-wrangling, no JSON parsing. Three question types:

• noul, a yes/no judgment, returned as a probability 0–1.
• choice, pick one of your labelled options; returns the choice plus a probability per option and a confidence.
• score, rate on a level scale; returns a probability-weighted score plus the distribution.

// api/triage.js — included, no key:
const d = await env.AI.decide({
  state: message,
  questions: {
    is_urgent:  { type: "noul", instructions: "Does this convey urgency?" },
    department: { type: "choice", instructions: "Which team?", criteria: { billing: "Payments", technical: "Bugs" } },
    frustration:{ type: "score", instructions: "How frustrated?", criteria: ["Calm", "Frustrated", "Very angry"] },
  },
});
// d.answers.is_urgent.noul   → 0.95
// d.answers.department.choice → "billing" (+ .probabilities, .confidence)
// d.answers.frustration.score → 1.05       (+ .probabilities, .confidence)

// Same interface, bring-your-own TypeSafe key (set TYPESAFE_API_KEY):
const j = await env.AI.jev({ state: message, questions: { is_urgent: { type: "noul", instructions: "Urgent?" } } });

Want to call a vendor on your own account (your billing, your key)? Set the provider's key as an app env var (via manage_app_env, action: set) and that provider's calls go straight to the vendor, Cloudrizz never sees the key and bills nothing. Without the key these throw byo_key_required. Note this is a separate path from env.AI.run("openai/…") above (which is key-free on your AI credits), use BYO when you specifically want it billed by the vendor, or for a model Cloudflare doesn't serve.

• env.AI.openai → OPENAI_API_KEY. OpenAI Chat Completions shape.
• env.AI.anthropic → ANTHROPIC_API_KEY. Anthropic Messages shape.
• env.AI.google (alias env.AI.gemini) → GOOGLE_API_KEY. Gemini generateContent shape (model + contents, not messages).
• env.AI.jev / env.AI.typesafe → TYPESAFE_API_KEY. Typed decisions.

// api/ask.js — requires OPENAI_API_KEY / ANTHROPIC_API_KEY / GOOGLE_API_KEY
const openai = await env.AI.openai.chat({ model: "gpt-5", messages: [{ role: "user", content: q }] });
const claude = await env.AI.anthropic.chat({ model: "claude-sonnet-4-6", max_tokens: 1024, messages: [{ role: "user", content: q }] });
const gemini = await env.AI.google.chat({ model: "gemini-2.5-flash", contents: [{ role: "user", parts: [{ text: q }] }] });

Every included and run-by-id call (purpose methods, env.AI.run on @cf/… ids, and the key-free provider models) is metered to your org's AI credits (1 credit = 1¢). Each plan includes a monthly grant; buy top-up packs for more. Text models bill by token, media by output unit. Bring-your-own-key calls bill you nothing on Cloudrizz, the vendor bills your account directly.

• When credits hit zero, included / run-by-id calls fail with out_of_credits (HTTP 402). Buy a top-up pack, wait for the monthly refill, or switch that call to a bring-your-own-key model.
• Check the balance and usage in your dashboard under AI credits.
• A model without an explicit price bills a small flat per-call amount (never free), models you're likely to use are priced by token.

See Limits & quotas for the per-plan grants.

Exact rates, kept in sync with what we bill. 1 credit = 1¢ (so 100 credits = $1). Text models bill per token, split into input (the prompt + context you send) and output (what the model writes back), quoted here per 1M tokens. As a feel for it, a short chat turn is typically a few hundred to a few thousand tokens, so a llama-3.3-70b reply costs a tiny fraction of a credit. There's a per-model floor (most calls round up to at least 1 credit).

Included models (by purpose / clean name). What env.AI.chat, research, code, decide and friends run, and what env.AI.run("<clean-name>") pins:

Provider models via Cloudflare (key-free). Called by full id with env.AI.run("openai/…") etc., billed to your credits by token just like the included models:

Generative media. Billed per output unit (an image, or a second of video / audio), so a longer clip costs more. The “typical call” column is the default length:

Flat per-call models. A few models don't report token usage, so they bill a flat amount per call regardless of size:

Web tools. env.AI.search and env.AI.browse (the Live web section above) each bill a flat 1 credit per call.

A failed call throws an Error with status and code fields. Wrap calls in try / catch and branch on e.code:

try {
  const res = await env.AI.run("openai/gpt-6-luna", { input: question, max_output_tokens: 512 });
  // …
} catch (e) {
  if (e.code === "out_of_credits") return Response.json({ error: "No AI credits left" }, { status: 402 });
  if (e.code === "byo_key_required") return Response.json({ error: "Set an API key for this model" }, { status: 400 });
  return Response.json({ error: e.message }, { status: e.status || 500 });
}