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.
Inhaltsverzeichnis
- What is claim verification?
- The 7-step fact-checking workflow
- Step 3 in practice: search the news record
- Step 4 in practice: count corroboration
- Step 5 in practice: triage by source signals
- A worked example, end to end
- Step 6 in practice: trace to the primary source
- Mapping the 5 pillars of verification to API fields
- Can fact-checking be automated?
- How do journalists verify sources?
- FAQ
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.
- 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.
- Map the claim to a query. Convert the claim into search terms plus filters: keywords for the title search, a
published_atwindow around the claimed date, and a language. - Search the news record. Query a news API for articles matching the claim within the window. (Code below.)
- Count corroboration. Count how many independent sources reported it, not how many articles exist — duplicates and one syndicated story inflate raw counts. (Code below.)
- Triage by source signals. Score the result set on source credibility, bias, country spread, and freshness using the metadata each article carries.
- 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.
- 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) | Corroborated | Single-source / unverified | No match |
|---|---|---|---|
| Independent source domains | ≥ 3 | 1–2 | 0 |
Country spread (country_code) | ≥ 2 | 1 | — |
Story clusters (story.id) | not all in one cluster | all one story.id | — |
Duplicates (is_duplicate) | mostly false | many true | — |
Source credibility (rankings.opr, bias) | mix incl. higher-OPR, non-uniform bias | low-OPR or single-bias echo | — |
| Routing | fast-track editor review | escalate, dig for primary source | flag 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_idfrom 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.
- Extract: entity = a European central bank; event = rate cut; date = 2026-06-14; place = Europe. Falsifiable — good.
- Map to query:
title=interest rate cut,language.code=en,published_at.start=2026-06-01,published_at.end=2026-06-15. - Search + count:
/countreturns8matches in the window. The/everythingresult set surfaces, among others,europesays.com(biasunknown, OPR 3),world-today-journal.com(biasright, OPR 3, flaggedis_duplicate: true), andcryptobriefing.com(OPR 5). - Independence check: drop the
is_duplicateitem; count distinct domains andcountry_codevalues on what remains. Suppose you are left with 4 independent domains across 2 countries, in 3 differentstory.idclusters. - 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 pillar | What it asks | API field(s) that inform it |
|---|---|---|
| Provenance | Is this the original, or a copy? | is_duplicate, story.id (cluster of echoes) |
| Quelle | Who is reporting, and are they credible? | source.domain, source.type, source.rankings.opr, source.bias |
| Date | When did this actually happen/publish? | published_at, is_breaking |
| Lage | Where is this from / about? | source.location.country_code, locations_mentioned |
| Motivation | Who 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.
Schlussfolgerung
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
Ressourcen
- APITube News API documentation — https://docs.apitube.io
- APITube
everythingandcountendpoints — 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


