Fact-checking workflow with a news API: 7 steps

Brian Hollis

Brian Hollis

·

21 minuti Leggi

Fact-checking workflow with a news API: 7 steps

Building a fact-checking workflow with a news API

A fact-checking workflow is a repeatable process that takes a single checkable claim and tests it against the news record before anyone publishes or acts on it. It has two halves: an automated retrieval layer that finds and counts how many independent sources corroborate a claim, and a human editorial layer that decides what the evidence means. This article shows how to build the first half with a news API and is explicit about where the second half must take over.

Disclosure: this is published on APITube's blog and the runnable examples use the APITube News API. The workflow's shape — search, count corroboration, triage, escalate to a human — is API-agnostic; you can implement it on any news API that exposes source metadata and full-text search.

This article is for newsrooms and Trust & Safety engineers who need to verify claims at a volume that manual checking can't keep up with, without pretending software can replace editorial judgment.

TL;DR — Key takeaways

  • A claim verification workflow has seven steps: extract the claim, map it to a query, search the news record, count corroboration, triage by source signals, trace to a primary source, then a human renders the verdict.
  • The API does the measurable part: it answers "how many independent sources, how credible, how fresh?" with real numbers — not "is this true?"
  • A practical corroboration threshold: ≥3 independent source domains across ≥2 countries, not all in one story cluster → treat as corroborated; 1–2 domains → single-source/unverified.
  • Automation has a hard boundary. A news API surfaces and counts the public news record; it does not adjudicate truth, detect doctored media, or verify a primary source's authenticity. A human editor owns the final call.

Indice dei contenuti

What is claim verification? {#what-is-claim-verification}

Claim verification is the process of isolating a single, falsifiable assertion and testing it against independent evidence to judge whether it is supported, contradicted, or unconfirmed. The unit of work is the claim, not the article: "the central bank cut rates by 50 basis points on June 14" is checkable; "the economy is in trouble" is not.

A news verification process turns that judgment into repeatable steps. The retrieval layer measures the news record around a claim — how many outlets reported it, how credible they are, when, and from where. The editorial layer interprets that signal. Confusing the two is the most common mistake teams make when they "automate fact-checking."

The 7-step fact-checking workflow {#workflow}

Here is the full claim verification workflow as an ordered pipeline. Each step starts with an action verb so it maps cleanly to code and to a newsroom runbook.

  1. Extract the checkable claim. Reduce the input to one falsifiable statement with named entities, a number or event, a date, and a place. Discard opinion and hedging.
  2. Map the claim to a query. Convert the claim into search terms plus filters: keywords for the title search, a published_at window around the claimed date, and a language.
  3. Search the news record. Query a news API for articles matching the claim within the window. (Code below.)
  4. Count corroboration. Count how many independent sources reported it, not how many articles exist — duplicates and one syndicated story inflate raw counts. (Code below.)
  5. Triage by source signals. Score the result set on source credibility, bias, country spread, and freshness using the metadata each article carries.
  6. Trace to a primary source. Follow the most credible articles back to the document, filing, dataset, or on-record statement they cite. The API gets you to the reporting; the primary source is the proof.
  7. Render a human editorial verdict. A person decides: supported, contradicted, needs-more-reporting, or unverifiable — and writes down why. This step is not optional.

Steps 3–5 are where a news API does real work. The rest is editorial discipline the API supports but cannot replace.

Step 3 in practice: search the news record {#search}

Use full-text search over the claim's keywords, constrained to a date window around the claimed event. With the APITube News API the endpoint is GET https://api.apitube.io/v1/news/everything:

curl "https://api.apitube.io/v1/news/everything\
?api_key=YOUR_API_KEY\
&title=interest%20rate%20cut\
&language.code=en\
&published_at.start=2026-06-01\
&published_at.end=2026-06-15\
&sort.by=published_at&sort.order=desc\
&per_page=20"

A trimmed result — note the fields that matter for verification, not the prose:

{
  "status": "ok",
  "results": [
    {
      "id": 3055045587,
      "title": "European Central Bank cuts interest rate amid regional tensions",
      "published_at": "2026-06-14T11:43:33.000Z",
      "source": {
        "domain": "europesays.com",
        "type": "news",
        "bias": "unknown",
        "rankings": { "opr": 3 },
        "location": { "country_code": "un" }
      },
      "story": { "id": 3055045587 },
      "is_duplicate": false,
      "is_breaking": false,
      "entities": [
        {
          "name": "European Central Bank",
          "type": "organization",
          "links": { "wikidata": "https://www.wikidata.org/wiki/Q8901" }
        }
      ]
    }
  ]
}

The verification-relevant fields are source.domain (who), source.bias and source.rankings.opr (how credible), source.location.country_code (where), published_at (when), is_duplicate and story.id (is this independent reporting or the same story echoed), and entities[].links.wikidata (is the actor a resolved, real-world entity).

Step 4 in practice: count corroboration {#count}

Raw article count is a trap: ten articles can be one wire story republished ten times. You want independent corroboration. An independent-domain count measures how many separate newsrooms reported a claim — which is the number that actually signals corroboration. Two measurements help.

First, a total match count over the window, via GET https://api.apitube.io/v1/news/count:

curl "https://api.apitube.io/v1/news/count\
?api_key=YOUR_API_KEY\
&title=interest%20rate%20cut\
&language.code=en\
&published_at.start=2026-06-01&published_at.end=2026-06-15"
{ "status": "ok", "count": 8, "request_id": "8c7f64d0-03fe-4df7-a04d-604b97dfcb9d" }

Second — and more important — count distinct source domains in the result set and drop items flagged is_duplicate or sharing a single story.id. That is the independence signal. In Python:

import requests

BASE = "https://api.apitube.io/v1/news"

def corroboration(claim_keywords, start, end, key):
    r = requests.get(f"{BASE}/everything", params={
        "api_key": key,
        "title": claim_keywords,
        "language.code": "en",
        "published_at.start": start,
        "published_at.end": end,
        "sort.by": "published_at",
        "sort.order": "desc",
        "per_page": 50,
    }, timeout=20)
    results = r.json().get("results", [])

    independent = [a for a in results if not a.get("is_duplicate")]
    domains = {a["source"]["domain"] for a in independent}
    countries = {a["source"]["location"]["country_code"] for a in independent}
    clusters = {a.get("story", {}).get("id") for a in independent}

    return {
        "articles": len(results),
        "independent_domains": len(domains),
        "countries": len(countries),
        "distinct_clusters": len(clusters),
    }

Now you have numbers an editor can reason about, instead of a vague "lots of outlets are saying it."

Step 5 in practice: triage by source signals {#triage}

Convert the counts and per-source metadata into a triage verdict with explicit thresholds. Treat this as a first-pass filter that routes work to a human, never as the final ruling.

Signal (from API)CorroboratedSingle-source / unverifiedNo match
Independent source domains≥ 31–20
Country spread (country_code)≥ 21—
Story clusters (story.id)not all in one clusterall one story.id—
Duplicates (is_duplicate)mostly falsemany true—
Source credibility (rankings.opr, bias)mix incl. higher-OPR, non-uniform biaslow-OPR or single-bias echo—
Routingfast-track editor reviewescalate, dig for primary sourceflag as unsupported by news record

source.rankings.opr (Open PageRank) and source.bias are returned signals you score client-side, not a magic "credibility filter" you can pass as a server-side parameter. Open PageRank measures link authority, not truthfulness — a high-OPR outlet can still be wrong. Use these to prioritize human attention, not to decide.

Pro tip: Persist every run — claim, query, counts, the request_id from the API, and the editor's verdict. That timestamped record is your audit trail when a verdict is challenged later.

A worked example, end to end {#worked-example}

Take the claim: "A European central bank cut interest rates on June 14, 2026." Run it through the pipeline.

  1. Extract: entity = a European central bank; event = rate cut; date = 2026-06-14; place = Europe. Falsifiable — good.
  2. Map to query:title=interest rate cut, language.code=en, published_at.start=2026-06-01, published_at.end=2026-06-15.
  3. Search + count:/count returns 8 matches in the window. The /everything result set surfaces, among others, europesays.com (bias unknown, OPR 3), world-today-journal.com (bias right, OPR 3, flagged is_duplicate: true), and cryptobriefing.com (OPR 5).
  4. Independence check: drop the is_duplicate item; count distinct domains and country_code values on what remains. Suppose you are left with 4 independent domains across 2 countries, in 3 different story.id clusters.
  5. Triage verdict: 4 domains ≥ 3, 2 countries ≥ 2, not one cluster → corroborated, fast-track to an editor. Had it been one domain echoed eight times, the row would read single-source instead.

The API got you a defensible "the news record supports this, here are the numbers." It did not tell you the cut actually happened — that is Step 6.

Step 6 in practice: trace to the primary source {#primary-source}

Corroboration tells you outlets agree; it does not tell you they are right. Follow the highest-credibility article's href to the reporting, then to the primary source it cites — in this example, the central bank's own rate-decision page or press release. A claim is verified when you reach the primary record, not when the article count looks reassuring. The API points you at the door; you still have to walk through it.

Mapping the 5 pillars of verification to API fields {#pillars}

First Draft's widely used "5 pillars of verification" (provenance, source, date, location, motivation) predate any API, but each pillar maps to concrete fields — which is how you bridge editorial standards and an automated pipeline.

Verification pillarWhat it asksAPI field(s) that inform it
ProvenanceIs this the original, or a copy?is_duplicate, story.id (cluster of echoes)
FonteWho is reporting, and are they credible?source.domain, source.type, source.rankings.opr, source.bias
DateWhen did this actually happen/publish?published_at, is_breaking
PosizioneWhere is this from / about?source.location.country_code, locations_mentioned
MotivationWho are the actors and what's their stake?entities[] with links.wikidata, sentiment.overall

The pillars still belong to the human. The API just makes each one measurable and fast.

Can fact-checking be automated? {#automation-boundary}

Fact-checking can be partially automated: the retrieval and corroboration-counting layer scales well, but the verdict cannot be fully automated, because judging truth requires reasoning a news API does not perform.

Here is the hard boundary. A news API can:

  • Find every article matching a claim in a time window.
  • Count independent sources, countries, and story clusters.
  • Surface source credibility, bias, freshness, and resolved entities.

A news API cannot:

  • Decide whether the claim is true — corroboration is evidence of reporting, not proof of fact. Many outlets repeating an error is still an error.
  • Detect doctored images, video, or fabricated quotes.
  • Verify the authenticity of a primary source (a leaked document, a filing, an on-record statement).
  • Read intent or judge whether a true-but-misleading framing deserves a correction.

So the honest architecture is human-in-the-loop: automate Steps 3–5 to triage hundreds of claims down to the few that need a person, then spend editorial time where it matters. Anyone selling fully automated truth is selling the part that doesn't exist.

How do journalists verify sources? {#verify-sources}

Journalists verify sources by corroborating across independent outlets, tracing claims to primary records, and weighing each source's track record and potential bias — the same logic this workflow encodes. The API accelerates the corroboration and triage; a reporter still does the calls, the document pulls, and the judgment. A workflow that respects this division ships faster and keeps the standards.

FAQ {#faq}

How do you fact-check a claim?

You fact-check a claim by isolating one falsifiable statement, searching the news record for independent reporting, counting how many credible sources corroborate it across different outlets and countries, tracing the strongest reporting to its primary source, and having a human editor render and document the verdict.

Can fact-checking be automated?

Fact-checking can be partly automated. The retrieval and corroboration-counting layer — searching the news record and measuring how many independent sources report a claim — scales well via an API. The final verdict on truth cannot be fully automated, because it requires human reasoning about evidence, primary sources, and intent.

What tools do fact-checkers use?

Fact-checkers use a mix: news APIs for searching and counting the news record, reverse-image and media-forensics tools for provenance, primary-source databases (government filings, court records, datasets), and structured-data standards like ClaimReview. A news API — you can test the corroboration step on APITube's free tier — covers the corroboration and source-triage layer of that stack.

What is claim verification?

Claim verification is the process of isolating a single falsifiable assertion and testing it against independent evidence to judge whether it is supported, contradicted, or unconfirmed. The unit is the claim, not the article.

How many sources confirm a claim?

A practical rule of thumb is at least three independent source domains across at least two countries, not all belonging to one story cluster. Fewer than that — or many duplicates of a single syndicated story — should be treated as single-source and escalated for primary-source verification rather than published as confirmed.

Does this lock me into one news API?

No, if you keep the claim-to-query mapping, corroboration thresholds, and triage logic in your own code. The only API-specific parts are the endpoint and field names. Because the workflow depends on common signals — source domain, date, duplication, credibility — it ports to any news API that exposes them.

Conclusion

A fact-checking workflow built on a news API is not a truth machine — it is a triage machine. It searches the news record, counts independent corroboration with real numbers, and routes the hard cases to the people who should decide them, with an audit trail behind every call. Automate the measurable layer, respect the editorial boundary, and you get speed without surrendering the standard. That is the whole point of a claim verification workflow: more claims checked, none of them rubber-stamped by software.

Try Apitube free → apitube.io

Risorse

  • APITube News API documentation — https://docs.apitube.io
  • APITube everything and count endpoints — https://docs.apitube.io
  • First Draft / Information Futures Lab — verification resources — https://firstdraftnews.org
  • Poynter / International Fact-Checking Network — https://www.poynter.org/ifcn/
  • ClaimReview structured-data standard — https://schema.org/ClaimReview
APITube - News API

Articoli correlati

How to Detect Misinformation by Cross-Referencing Sources
Developer Guides

How to Detect Misinformation by Cross-Referencing Sources

Detect misinformation by cross-referencing sources: score corroboration breadth, source authority, and bias diversity over a news API. Code included.

Check news claims with AI: a Python guide (2026)
Developer Guides

Check news claims with AI: a Python guide (2026)

Build a fact-checking workflow that extracts claims, finds articles with APITube, compares evidence, and explains results. Includes code and common failure modes.

News Source Credibility 2026: How to Score It
Insights

News Source Credibility 2026: How to Score It

How to score news source credibility: how NewsGuard and Ad Fontes rate outlets, a tunable Python trust score from real API signals, and when to go hybrid.

Verify Breaking News Before You Act: Risk Checklist
Insights

Verify Breaking News Before You Act: Risk Checklist

Verify breaking news before you trade, hedge or publish: a 7-step checklist and a stakes-based rule for how many sources to confirm before you act.

Utilizziamo i cookie

Facendo clic su "Accetta", accetti i cookie sul tuo dispositivo affinché il sito funzioni e per l'analisi.