The AI Fact-Check Workflow

Part 2, Claim Extraction with DeepSeek 3.2

What counts as an atomic claim

The pipeline only works if step 2 extracts the right things. An atomic claim is one factual statement that can be true or false on its own.

Examples of atomic claims:

• "GPT-4 was released in March 2023."
• "Brave Search has a free tier of 2,000 queries per month."
• "California has a population of approximately 39 million people."

Not atomic claims:

• "GPT-4 was released last year and quickly became popular." (Two claims, both verifiable separately. Split.)
• "Brave Search is a great choice for fact-checking." (Opinion, not a factual claim. Skip.)
• "Many users prefer Brave over Google." (Vague, hard to verify. Skip or rewrite as testable.)

The extraction prompt below explicitly tells the model to skip opinions, vague generalizations, and any sentence that is not a directly verifiable factual statement.

The OpenRouter call

import OpenAI from "openai";

const openai = new OpenAI({
  baseURL: "https://openrouter.ai/api/v1",
  apiKey: process.env.OPENROUTER_API_KEY,
  defaultHeaders: {
    "HTTP-Referer": "https://your-site.com",
    "X-Title": "Fact Check Pipeline",
  },
});

interface Claim {
  id: number;
  text: string;
  type: "statistic" | "quote" | "date" | "attribution" | "factual_statement";
  context: string;
}

async function extractClaims(draft: string): Promise<Claim[]> {
  const response = await openai.chat.completions.create({
    model: "deepseek/deepseek-v3.2",
    messages: [
      { role: "system", content: EXTRACTION_SYSTEM_PROMPT },
      { role: "user", content: `Draft to analyze:\n\n${draft}` },
    ],
    response_format: { type: "json_object" },
    temperature: 0.1,
  });

  const parsed = JSON.parse(response.choices.message.content!);
  return parsed.claims;
}

Three things worth noting in the call:

• Model: deepseek/deepseek-v3.2 via OpenRouter. Substitute another model if you prefer; the prompt and the JSON shape stay the same.
• response_format: { type: "json_object" } forces structured output. Without it the model occasionally returns prose with embedded JSON, which breaks the parser.
• temperature: 0.1 keeps the extraction deterministic. You want the same draft to produce the same claim list every run.

The system prompt

You are a careful fact-checking assistant. Your job is to read a draft article and extract every atomic factual claim that can be verified against an independent source.

DEFINITIONS:
- An ATOMIC CLAIM is one factual statement that can be true or false on its own.
- A factual claim has a specific subject, a specific predicate, and is testable against external evidence.

INCLUDE these claim types:
- Statistics ("X% of Y do Z", "approximately N million people", any number with attribution)
- Quotes ("A said B")
- Dates and timeframes ("X happened in Y", "X was released on Y")
- Attributions ("X invented Y", "X was founded by Y")
- Specific factual statements ("X is the capital of Y", "X costs Y")

EXCLUDE these:
- Opinions ("X is the best", "X is impressive")
- Vague generalizations ("Many people use X", "X is popular")
- Hypotheticals ("If X happened, Y would follow")
- The author's first-person experience ("In my work I've found X")
- Definitions of common terms

OUTPUT JSON SHAPE:
{
  "claims": [
    {
      "id": 1,
      "text": "The exact claim, rewritten as a single sentence",
      "type": "statistic" | "quote" | "date" | "attribution" | "factual_statement",
      "context": "The original sentence or surrounding context, verbatim from the draft"
    },
    ...
  ]
}

If a sentence contains multiple atomic claims, split them into separate entries. If a sentence contains no atomic claim, do not emit anything for it. Return only valid JSON. No commentary, no markdown wrapper.

Why each rule earns its place

The exclusion list matters more than the inclusion list. If you do not explicitly tell the model to skip opinions and vague generalizations, you end up trying to "verify" things like "AI is changing the industry," which has no verification. Wasted API calls. Wasted attention.

The context field matters for annotation. When you go back to mark claims as verified or contradicted in step 5, you need to know exactly where in the draft the claim came from. Storing the original sentence with each extracted claim lets the annotation step do find-and-replace cleanly.

The type field matters for routing. Some claim types (quotes, attributions) often need higher-credibility sources than others (general dates, common statistics). The annotation step in Part 4 uses the type to decide whether a low-credibility source is acceptable.

Sample output

Input draft (excerpt):

DeepSeek 3.2 returns:

{
  "claims": [
    {
      "id": 1,
      "text": "GPT-4 was released by OpenAI in March 2023.",
      "type": "date",
      "context": "GPT-4 was released by OpenAI in March 2023, more than two years after GPT-3."
    },
    {
      "id": 2,
      "text": "GPT-4 was released more than two years after GPT-3.",
      "type": "factual_statement",
      "context": "GPT-4 was released by OpenAI in March 2023, more than two years after GPT-3."
    },
    {
      "id": 3,
      "text": "GPT-4 was the first model to handle image inputs natively.",
      "type": "factual_statement",
      "context": "It was the first model to handle image inputs natively."
    }
  ]
}

Note that "Many businesses adopted it within months of release" is correctly excluded (vague generalization, not verifiable). Three atomic claims emitted, each with the original context for downstream find-and-replace.

Cost and timing

Typical extraction call for a 1,500-word article:

• Input: about 1,500 tokens (the system prompt plus the draft)
• Output: about 800 tokens (the structured claims)
• Cost on DeepSeek 3.2: under one tenth of a cent
• Latency: 4 to 8 seconds

The whole step runs faster and cheaper than a single Google search. The output drives every subsequent step in the pipeline.

---

Part 3, The Brave Search and AI Grounding Hybrid

When to use which

The hybrid pattern uses two Brave APIs with different cost and quality profiles:

Routing rule: call Web Search first on every claim. If Web Search returns no results, or only returns low-credibility domains, escalate that one claim to AI Grounding. Most claims clear at the cheap tier.

The Brave Web Search call

interface BraveSearchResult {

  url: string;
  description: string;
}

async function searchBrave(query: string): Promise<BraveSearchResult[]> {
  const response = await fetch(
    `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=10`,
    {
      headers: {
        "Accept": "application/json",
        "X-Subscription-Token": process.env.BRAVE_API_KEY!,
      },
    }
  );

  if (!response.ok) {
    throw new Error(`Brave Search failed: ${response.status}`);
  }

  const data = await response.json();
  return (data.web?.results ?? []).map((r: any) => ({

    url: r.url,
    description: r.description,
  }));
}

The query you send matters more than the API. For a claim like "GPT-4 was released by OpenAI in March 2023," do not search the whole sentence. Search a phrase that should appear on a credible source page:

• Bad query: GPT-4 was released by OpenAI in March 2023
• Good query: "GPT-4" release date OpenAI
• Good query: OpenAI GPT-4 announcement March 2023

Wrap the search in a small query-rewrite step (one more cheap LLM call) that turns each atomic claim into one or two effective search queries. Costs roughly nothing and dramatically improves first-page hit rates.

Source-credibility scoring

Before you trust a Web Search result, score the URL's credibility based on its domain. Three tiers:

type Credibility = "high" | "medium" | "low";

function scoreCredibility(url: string): Credibility {
  try {
    const domain = new URL(url).hostname.toLowerCase();

    const high = [
      ".edu", ".gov", ".ac.uk",
      "nih.gov", "cdc.gov", "who.int",
      "nature.com", "science.org", "pnas.org",
      "ncbi.nlm.nih.gov", "pubmed",
      "sciencedirect.com", "springer.com", "wiley.com",
    ];
    if (high.some(d => domain.endsWith(d) || domain.includes(d))) {
      return "high";
    }

    const medium = [
      "wikipedia.org",
      "bbc.com", "nytimes.com", "wsj.com",
      "economist.com", "reuters.com", "apnews.com",
    ];
    if (medium.some(d => domain.includes(d)) || domain.endsWith(".org")) {
      return "medium";
    }

    return "low";
  } catch {
    return "low";
  }
}

The list is opinionated. Adjust to your domain. For science topics, weight academic and government sources heavily. For business topics, add Reuters, Bloomberg, and Wall Street Journal as high-credibility. For local news, add specific local outlets.

The hybrid routing logic

type VerificationStatus = "verified" | "unverified" | "contradicted";

interface Citation {
  url: string;

  snippet: string;
  credibility: Credibility;
  source: "brave_web" | "brave_grounding";
}

interface VerificationResult {
  claim: string;
  status: VerificationStatus;
  citation?: Citation;
}

async function verifyClaim(claim: Claim): Promise<VerificationResult> {
  // Step 1: try Brave Web Search (free)
  const queries = await rewriteQueries(claim.text);
  for (const query of queries) {
    const results = await searchBrave(query);
    const best = results
      .map(r => ({ ...r, credibility: scoreCredibility(r.url) }))
      .find(r => r.credibility !== "low");

    if (best) {
      return {
        claim: claim.text,
        status: "verified",
        citation: {
          url: best.url,

          snippet: best.description,
          credibility: best.credibility,
          source: "brave_web",
        },
      };
    }
  }

  // Step 2: escalate to Brave AI Grounding
  const grounding = await braveAIGrounding(claim.text);
  if (grounding.found) {
    return {
      claim: claim.text,
      status: "verified",
      citation: {
        url: grounding.citations.url,

        snippet: grounding.answer ?? "",
        credibility: scoreCredibility(grounding.citations.url),
        source: "brave_grounding",
      },
    };
  }

  // Step 3: nothing found at either tier
  return { claim: claim.text, status: "unverified" };
}

Three rules built into this logic:

1. Skip low-credibility Web Search results entirely. A "low" credibility URL is worse than nothing because it gives false confidence. If the only Web Search result is a random Medium post, treat the claim as unverified at the cheap tier and escalate.

2. Take the first usable result. Do not run multiple Web Search queries hoping for a better citation. The escalation to AI Grounding is the better-quality path.

3. An unverified claim is not the same as a contradicted claim. "Unverified" means we could not find evidence either way. "Contradicted" means we found credible evidence that disagrees. The annotation step (Part 4) handles them differently.

The Brave AI Grounding call

async function braveAIGrounding(query: string) {
  const response = await fetch(
    "https://api.search.brave.com/res/v1/ai/search",
    {
      method: "POST",
      headers: {
        "Accept": "application/json",
        "Content-Type": "application/json",
        "X-Subscription-Token": process.env.BRAVE_API_KEY!,
      },
      body: JSON.stringify({
        query: query,
      }),
    }
  );

  const data = await response.json();
  return {
    found: !!data.answer,
    answer: data.answer,
    citations: data.citations ?? [],
  };
}

The response includes both an AI-generated summary and a list of citations with URLs and snippets. The summary is useful for display ("here is what credible sources say about this claim"). The citations are the verifiable artifact.

Detecting contradictions

The trickiest case: the search returns credible sources, but they contradict the claim. To catch this, run one more cheap DeepSeek call comparing the claim to the citation snippet:

async function checkContradiction(claim: string, snippet: string): Promise<boolean> {
  const response = await openai.chat.completions.create({
    model: "deepseek/deepseek-v3.2",
    messages: [
      {
        role: "system",
        content: "You compare a claim to a citation snippet and determine if they agree, disagree, or are unrelated. Respond with ONE word only: AGREES, DISAGREES, or UNRELATED.",
      },
      {
        role: "user",
        content: `CLAIM: ${claim}\n\nCITATION SNIPPET: ${snippet}\n\nDoes the snippet agree with, disagree with, or have nothing to say about the claim?`,
      },
    ],
    temperature: 0,
    max_tokens: 5,
  });

  const verdict = response.choices.message.content?.trim().toUpperCase();
  return verdict === "DISAGREES";
}

Costs essentially nothing per claim and catches the case where a confident hallucination ("the population of California is 78 million") finds a credible source that disagrees ("the population of California is approximately 39 million").

Cost summary for one article

For 25 atomic claims:

• Web Search calls: 25 (free, within 2,000/month tier)
• AI Grounding escalations: typically 4 to 6 (the claims Web Search could not handle)
• Contradiction checks: 25 cheap DeepSeek calls

Total verification cost: roughly 2 to 3 cents per article. Most of it is the AI Grounding escalation budget.

---

Part 4, Annotation, Audit Trail, and a Worked Example

Annotating the final draft

Once you have the verification results for every claim, the annotation step writes them back into the article. Two output formats to choose between:

Format A, inline footnote markers. Add a numbered citation marker after each claim. Add a citations list at the end. Best for articles that will be published as-is to a website or PDF.

Format B, structured comments. Add HTML or Markdown comments around each claim with the verification status. Best for handing the article to a human editor for final review.

Format A example

Original sentence:

Annotated:

Format B example

<!-- claim:1 status:verified credibility:high source:openai.com -->
GPT-4 was released by OpenAI in March 2023, more than two years after GPT-3.
<!-- /claim:1 -->

The annotation step is itself a small DeepSeek call: feed in the original draft plus the verification results JSON, ask for the annotated version. Cost: about a tenth of a cent.

Handling unverified and contradicted claims

Two cases that need different treatment:

Unverified claims (no credible source found at either tier): mark them visibly. Either strikethrough in the editor's view or flag with a [CITATION NEEDED] marker. Do not silently leave them in. The editor decides whether to keep the claim with a manual citation, soften the language, or remove the claim entirely.

Contradicted claims (a credible source disagrees): mark them with the contradicting source. The editor decides whether the claim is wrong (correct it) or whether the contradiction is itself wrong (rare, but possible). Either way, the contradicting source goes in the audit trail.

The pipeline's job is not to make these editorial decisions. The pipeline's job is to surface the right information so the human editor makes the decision in seconds instead of minutes.

The git repo layout

One repo per project (or per content team). The layout:

fact-check-pipeline/
├── prompts/
│   ├── extract-claims.md         (the system prompt from Part 2)
│   ├── rewrite-queries.md        (claim → search query rewriter)
│   ├── check-contradiction.md    (claim vs snippet checker)
│   └── annotate-draft.md         (final annotation step)
│
├── src/
│   ├── pipeline.ts               (the orchestrator)
│   ├── extract.ts                (DeepSeek extraction call)
│   ├── search.ts                 (Brave Web Search wrapper)
│   ├── grounding.ts              (Brave AI Grounding wrapper)
│   ├── credibility.ts            (URL credibility scoring)
│   ├── verify.ts                 (the hybrid verification logic)
│   └── annotate.ts               (final annotation generator)
│
├── articles/
│   └── 2026-04-24-ai-fact-checking/
│       ├── draft.md              (the original AI draft)
│       ├── claims.json           (extracted claims)
│       ├── citations.json        (verification results with citations)
│       ├── annotated.md          (the final annotated draft)
│       └── audit.json            (timestamps, costs, models used)
│
├── citation-cache/
│   └── (claim hash) → cached verification result
│
└── README.md

Three things this layout earns:

1. Versioned prompts. The prompts/ folder holds every system prompt as a separate file. Improvements to the extraction prompt are tracked in git history. You can A/B test prompt versions cleanly.

2. Per-article audit trail. Each article gets its own folder with the draft, the claims, the citations, the final, and an audit log. If anyone questions a citation in a published article, you have the full chain.

3. Citation cache. The same claim ("GPT-4 was released in March 2023") may appear in multiple articles. The cache prevents re-verification. Keyed by a hash of the normalized claim text. Saves money at scale.

A complete worked example

A 1,500-word article on the topic "Why most AI startups die in their first year." Run end-to-end through the pipeline.

Step 1, Generate. DeepSeek 3.2 produces the draft. About 1,500 words, 4,200 characters of prose. Cost: $0.002.

Step 2, Extract claims. DeepSeek 3.2 identifies 28 atomic claims. Cost: $0.001. Sample claims:

• "Approximately 90% of startups fail."
• "Y Combinator was founded in 2005."
• "OpenAI raised $10 billion from Microsoft in 2023."
• "Most AI startups burn through their seed funding within 18 months."

Step 3, Search. Brave Web Search runs against all 28 claims. Cost: $0 (within free tier). Results:

• 22 claims clear with a high or medium-credibility source on the first page
• 6 claims return only low-credibility results or no results

Step 4, Verify. The 6 unhandled claims escalate to Brave AI Grounding. Cost: 6 × $0.004 = $0.024. Plus token costs of about $0.005. Total: about $0.029. Results:

• 4 of the 6 claims clear with credible AI Grounding sources
• 1 claim ("Most AI startups burn through their seed funding within 18 months") returns sources that disagree (industry data suggests 12 to 24 months range, with high variance), flagged as needs-revision
• 1 claim ("OpenAI raised $10 billion from Microsoft in 2023") returns sources confirming the amount but with the date wrong (the deal was announced in January 2023 but the actual investment was multi-tranche through 2023), flagged as needs-clarification

Step 5, Annotate. DeepSeek 3.2 takes the original draft plus the 28 verification results and produces an annotated version. 26 claims marked verified with footnotes, 2 claims marked with [NEEDS REVISION] and the contradicting context. Cost: $0.001.

Step 6, Commit. The whole article folder commits to git. Total run time end-to-end: about 70 seconds.

Total cost: $0.033 per article. Total time: about 70 seconds. Output: a fully annotated draft with verification status and citations on every claim, plus a complete audit trail in git.

The 2 needs-revision claims become a 5-minute editor pass. The other 26 are publication-ready.

Where the pipeline fails (and what to do about it)

Three known failure modes:

1, Recent events (last 30 days)

Brave's index, like Google's, lags real-time events. A claim about "what happened yesterday" may not have credible sources indexed yet. For news-driven content, supplement the pipeline with a manual check on anything within the last week.

2, Highly technical or niche claims

A claim about a specific protein interaction, a specific enterprise software pricing tier, or a specific obscure historical event may not have a credible web source even though the claim is correct. Manual verification needed for these.

3, Subjective or contested claims

"Most experts agree X" (even when accurate) is hard to verify because the source for "most experts agree" is itself subjective. Either rewrite to something verifiable ("78% of surveyed experts in [study]...") or remove.

The pipeline catches roughly 90 to 95% of fact-check needs at production cost. The remaining 5 to 10% is where human editorial judgment still earns its keep.

---

Closing

The AI Fact-Check Workflow is one cheap drafting model, two Brave APIs, one cheap annotation step, and a git repo. The whole thing runs in under 90 seconds for under three cents per article.

If you only do three things from this playbook:

1. Treat every AI draft as needing fact-checking. No exceptions for "easy" topics. Hallucinations show up where you least expect them.
2. Use the cheap Web Search tier for everything first. Most claims clear there. Only escalate to AI Grounding (or a human reviewer) when Web Search returns nothing usable.
3. Commit every article through git with its full audit trail. Prompts versioned, citations cached, decisions traceable. The audit trail is what makes the pipeline defensible at scale.

Built more like this at the Massive Impact resource library.

---