Cloudflare Clairic: Typed Data Extraction With Confidence

Clairic is a preview extraction model that Cloudflare released on Workers AI on October 19, 2026, as @cf/cloudflare/clairic. You send it text (plus up to four images) and a schema of typed fields, and in one forward pass it returns values, calculations, estimates and forecasts, each with a confidence score or an 80% interval. It costs $0.10 per million input tokens with no output-token charge, which makes it a cheap first step for data enrichment and for agents that need to know when they might be wrong.

I've spent a fair amount of time on data-enrichment pipelines, and one use of LLMs has always bothered me: paying a generative model to pull out information that is already sitting in the input. Say you're processing a company's website and want its headquarters, founding year, employee count and industry. The usual approach is to send the page to an LLM, ask for JSON, validate the response, and handle whatever went wrong. We're paying a model that can write software to copy a city name.

What is Cloudflare Clairic?

Cloudflare calls Clairic a "System One" model, borrowing Daniel Kahneman's split between fast, intuitive thinking and slow, deliberate reasoning. LLMs are the System Two side. Clairic answers all your fields in one parallel forward pass without generating tokens, so each answer is a value of the type you declared, or null when the model can't find one. It can still be wrong. It just can't hand you broken JSON or a date in the wrong format.

Cloudflare describes four kinds of output:

• Extracted values copied from the input, such as a name or an order ID, returned as spans with character offsets.

• Computed values worked out from the input, such as a total from price plus tax or the days between two dates.

• Estimated values the input doesn't state but gives evidence for, returned as a distribution inside bounds you set, with a median and an 80% interval.

• Forecasted values for future steps of a series, each with its own 80% interval.

The model page lists a 65,536-token context window and vision support. It's a preview, and Cloudflare says it intends to release open weights "soon." Today you can only call the hosted endpoint.

How is Clairic different from Clef and an LLM?

Cloudflare splits most model tasks into three kinds of output. A number or typed value goes to Clairic. A choice from a fixed set goes to Clef, its decision model, which returns a probability for every option you list. Open-ended text goes to an LLM. In Cloudflare's words, extraction models turn raw input into typed values, decision models turn values into decisions, and LLMs turn decisions into words.

Clef is a 27B multimodal model priced at $0.24 per million input tokens, and it takes 1 to 64 questions per request. In revenue terms, pulling the employee count out of a company profile is a Clairic job. Deciding whether that account is high, medium or low priority is a Clef job. Writing the first outreach email is still an LLM job. It's the same instinct I wrote about in The End of the Visual Web: give agents typed contracts to work with instead of asking them to guess.

What does a Clairic request look like?

A request has a state (the text to read) and a fields map. Each field gets a name, a type and optional plain-language instructions. Types include text, number, date, time, datetime, duration, list, estimate and forecast. Scalar answers come back with confidence and p_null, the probability that the value isn't in the input. Estimates come back with a median and a p10 to p90 range.

To try it you need Node.js and a Cloudflare account. Create a basic JavaScript Worker:

npm create cloudflare@latest -- clairic-demo
cd clairic-demo
npx wrangler login

Add a Workers AI binding to wrangler.jsonc. Model calls from local development still run on Cloudflare against your account, so they can incur usage charges.

Here is the Worker. The model: "clairic" selector is a required parameter in Cloudflare's current request schema.

export default {
  async fetch(request, env) {
    const invoice = `
      Invoice INV-2291 from Northwind Supply.
      Issued September 2, 2026.
      Payment terms: Net 30.
      Four pallets at $250 each.
      Shipping: $80.
      Contact: Dana Ruiz.
    `;
    const result = await env.AI.run("@cf/cloudflare/clairic", {
      model: "clairic",
      state: invoice,
      fields: {
        invoice_number: { type: "text", instructions: "Invoice identifier" },
        vendor: { type: "text", instructions: "Vendor name" },
        issue_date: { type: "date", instructions: "Invoice issue date" },
        total_amount: {
          type: "number", decimals: 2, unit: "USD",
          instructions: "Total amount including shipping"
        }
      }
    });
    return Response.json(result);
  }
};

The total_amount field needs arithmetic: four pallets at $250 plus $80 shipping is $1,080. Run npx wrangler dev, hit http://localhost:8787, and check answers.total_amount.value against 1080. Keep the full response so you can trace any odd answer back to its confidence and p_null.

The Worker builds with Wrangler 4.151.3, and a dry run validates the bundle (0.90 KiB, 0.47 KiB gzipped). A dry run doesn't call the model, though, and I haven't made the live call yet, so the response I quote below is Cloudflare's, not mine.

Cloudflare's model docs run almost the same invoice and publish the output. The total comes back as 1080 with confidence 0.9999. A due date of 2026-10-02 is computed from "net 30." The PO number, which isn't on the invoice, comes back null with a p_null of 1. That null is what I care about most: Cloudflare's point is that a missing field comes back empty instead of as a plausible-looking guess.

How much does Clairic cost for company enrichment?

At $0.10 per million input tokens, here is what inference alone would cost if each company took 2,000 billed input tokens:

Companies	Input tokens	Inference cost
1,000	2 million	$0.20
10,000	20 million	$2.00
100,000	200 million	$20.00
1,000,000	2 billion	$200.00

These are calculations, not bills, and the 2,000-token figure is an assumption. Your field schema is billed too. In Cloudflare's invoice example, the invoice text was 61 tokens, the schema was 472, and the response reported 655 input tokens across three passes. With short inputs and many fields, the schema can cost more than the document. There's no cap on field count: fields that don't fit next to the input in one 8,192-token pass get split into parallel passes that each see the whole input. Measure the usage block on real records before you trust any per-record number. Crawling, storage and retries cost extra.

Cloudflare also published an end-to-end comparison on a damaged-product claim. Clairic for extraction, Clef for the decision and GLM-5.3 for the reply took 19.3 seconds and $6,032 per million claims. Running all three steps on GLM-5.3 took 61.7 seconds and $11,740. Clairic and Clef together took under a second (0.46 s and 0.22 s); GLM-5.3 needed 38 seconds for the same two steps. Both pipelines got the facts and the decision right in every run, but Clairic's repair estimate was identical each time while GLM-5.3's varied ($250, $250 and $220).

How would I use Clairic in a revenue agent?

At Sprouts.ai we build AI revenue agents, and a lot of their work starts with turning unstructured signals into fields: an About page, a press release, a job post, a reply to an email. Most of those questions have answers you can't list in advance, which is where Clairic fits. Here's a field set for a fictional company description ("Acme Analytics was founded in 2018 and is headquartered in Austin, Texas. The company employs approximately 180 people and develops analytics software for enterprise customers."):

fields: {
  headquarters: {
    type: "text", instructions: "Company headquarters location"
  },
  founded_year: {
    type: "number", integer: true,
    instructions: "Year the company was founded"
  },
  employee_count: {
    type: "number", integer: true,
    instructions: "Approximate employee count"
  },
  industry: {
    type: "text", instructions: "Industry explicitly mentioned"
  }
}

Qualification signals follow the same pattern. A funding amount from a news item is an extraction. Days since that round is a duration, and the request takes a reference_date so the model isn't guessing what "today" is. Cloudflare's own suggestion for estimates is to score many items in one call, one estimate per candidate, lead or listing, and sort them in code.

The test I want to run involves conflicting sources. If a company's About page says 250 employees and an older press release says 120, which number does Clairic pick, and does its confidence drop enough to flag the conflict? A correct extraction also doesn't prove the number is current, so I'd store the source, the retrieval time, the value and the confidence together for every field.

How do confidence scores help agents know when they're unsure?

An LLM that estimates a value usually gives you a single number, and nothing downstream can tell a confident $180 from a shaky one. Clairic gives you three signals to route on: confidence, p_null, and the width of an estimate's 80% interval. Cloudflare's advice is to use them to decide what to automate and what to send for review, and its docs suggest human review before consequential or irreversible actions.

The cascade also limits prompt-injection exposure. In Cloudflare's example, Clef decides from a five-line summary of typed values instead of the raw email, and the LLM never sees the email at all. For agents that read untrusted web pages and inbound replies, that cuts down how much attacker-controlled text reaches the model that takes action. I made the broader case for these layered stacks in Why the 'Agent Stack' Is the Real Revolution, and a typed extraction step fits into that stack as one more layer.

The intervals do seem to mean something. In Cloudflare's TSA test, Clairic forecast the next day's checkpoint count for 21 days, was off by 3.3% on average, and 17 of the 21 actual counts landed inside its 80% interval. Three of the four misses fell on the Columbus Day weekend, which the series alone couldn't predict.

What are Clairic's limits right now?

Cloudflare is upfront that the current endpoint is an early checkpoint:

• One- and two-step arithmetic seems reliable. Longer chains and aggregating across many table rows aren't. Have Clairic pull the values and let your code do the math.

• Estimates need evidence in the input, such as comparables, history or descriptive text.

• Intervals are trained to be calibrated, but they can run narrow on unfamiliar data.

• Forecasting is basic and won't replace a dedicated time-series model for long-horizon work.

• A typed answer is well formed, not necessarily correct. Estimates and forecasts also return a prediction even when the input says very little.

For complex invoices or deal data, I'd extract the line items with Clairic and do the totals in application code.

What would I benchmark before production?

I'd take 1,000 company records with verified values and run Clairic against our existing LLM extraction on the same source material, measuring:

• Exact-match accuracy on names, dates, locations and numbers

• Answers returned without enough evidence in the source

• Correct null answers for fields that aren't there

• End-to-end latency, including retries

• Cost per verified record: total inference cost divided by correct records

The test set should include conflicting employee counts, missing fields, badly formatted pages and multiple dates. I'd check how well confidence tracks errors before picking a threshold for automation. If Clairic gets the value right, returns null when it should, and gives low confidence to its own mistakes, that's when I'd start moving records out of the old pipeline.

Frequently asked questions

How much does Cloudflare Clairic cost?

$0.10 per million input tokens on Workers AI, with no charge for output tokens. Your field schema counts toward input tokens, so check the usage field in responses.

What is the difference between Clairic and Clef?

Clairic returns typed values, such as text spans, numbers, dates, estimates and forecasts, that you can't list in advance. Clef picks among options you define and returns a probability for each. Cloudflare's own example uses Clairic to extract facts and Clef to decide what to do with them.

Is Clairic open source?

Not yet. It's a hosted preview on Workers AI. Cloudflare says it intends to release open weights soon but hasn't given a date.

Can Clairic read images?

Yes. A request can include up to four embedded PNG, JPEG or WebP images (4 MiB each, 8 MiB total). Remote image URLs aren't accepted.

Does Clairic hallucinate?

It can't return malformed or mistyped output, and it returns null when it can't find a value. It can still return a wrong value, so use confidence, p_null and intervals to decide what needs review.

Sources

• Introducing Clairic, a new System One class of extraction models (Cloudflare blog, October 19, 2026)

• Clairic model documentation and pricing (Cloudflare Workers AI docs)

• Extraction models (Cloudflare Workers AI docs)

• Clef model documentation and pricing (Cloudflare Workers AI docs)