EN PT ID

SPUR Coalition 2026: Content Telemetry for Publishers

November 19, 2026 · 11 min read · Industry Analysis

On 17 November 2026, DMGT — the owner of the Daily Mail, Metro, The i Paper and New Scientist — joined the board of SPUR, the publisher coalition known as the "NATO of news." That is the news headline. The more interesting fact sits one layer down: SPUR already publishes a working technical standard for proving how AI systems use a publisher's content, and it is open source.

The coalition is called SPUR — Standards for Publisher Usage Rights — and it now counts more than 80 members across over 20 countries, according to the coalition's own October announcement. The founding members are the BBC, Financial Times, Guardian Media Group, Telegraph Media Group, Sky News, the Associated Press, Mediahuis and CMA Media. The New York Times, AFP, The Economist and The Atlantic joined in October; DMGT joined the board in November.

What SPUR actually built is worth more attention than the membership list. On 2 October 2026 it published version 1.0 of the Content Telemetry Standard — an open schema, released under Apache 2.0, that defines five events covering the path a piece of content takes from a server into an AI answer and back out to a human.

For anyone publishing on X, Bluesky or LinkedIn, this is the first shared vocabulary for a problem that has been entirely private until now: you can see that your post was fetched, but you cannot tell whether it was read, used to ground an answer, cited, shown to a reader, or clicked. Telemetry turns that into five measurable events.

What Actually Changed in November

The DMGT announcement is a board appointment, not a product launch, and the framing matters. DMGT is not blocking crawlers. It joined the group that is writing the rules that everyone else will have to follow. Here is what the coalition looked like before and after:

DateEventWhy it matters
February 2026SPUR launches with eight founding partnersA publisher-led standards body, funded by its members, formed to set the rules rather than react to them.
3 June 202630 new members; CMA Media joins as a founding memberCoalition grows to 36 publishers and affiliates at the WAN-IFRA World News Media Congress.
12 June 2026Telemetry standard and profile published for public commentThe draft opens for a consultation window, with the repos public on GitHub from the start.
9 July 2026The Associated Press joins as a founding memberA US wire service joins the board, extending the coalition beyond Europe.
2 October 2026Content Telemetry Standard v.1 publishedThe framework becomes a usable specification, and the Licensing Advisory Board is announced alongside it.
13 October 2026NYT, AFP, The Economist, The Atlantic joinMembership passes 80 and covers more than 20 countries.
17 November 2026DMGT joins the boardThe group's largest reach yet: 90 million monthly readers across DMGT's consumer brands.

DMGT's own public policy managing director, Owen Meredith, framed the commercial threat plainly: AI platforms "are already starting to eat publisher's referral traffic as they provide answers by drawing on publisher material without consent or payment in most cases." SPUR's founder David Buttle put the goal more technically — the standard exists so publishers can "state how their content may be used, to see how it is actually used, and to show when those instructions are ignored."

The Five Events: How Your Content Actually Gets Used

This is the core of the standard, and it is the piece no outlet reported. Content Telemetry does not track "was my content scraped." It tracks five distinct boundaries, and the gaps between them are the story. A single retrieval can die at any step:

EventWhat it meansThe gap it reveals
content_retrievedContent was fetched over HTTPRetrieval without grounding: fetched, never used.
content_groundedContent entered the agent's generation contextGrounding without citation: it shaped the answer, you got no credit.
content_citedContent was explicitly referenced in the responseCitation without presentation: credited in the output, but the credit never reached the user.
content_presentedContent or a source reference became perceivable on a recipient-facing surfacePresentation without engagement: your link was shown, nobody clicked.
content_engagedA user clicked, copied, shared, or directed the agent to actThe only event a publisher feels in referrals and revenue.

The design decision that matters most is that these events are post-hoc. An agent cannot reliably declare how it will use content before reading it — a retrieved article may prove irrelevant. So the standard records what actually happened, not what the agent said it would do. The spec is explicit that this is a record of observable boundaries, not a window into model internals.

One detail in the specification is easy to miss and useful for anyone building tooling: the grounding event is architecture-neutral and decoupled from retrieval. Content cached by an agent for days still produces a grounding event in every session it influences. And presentation does not prove attention — an agentic browser can render a page that never entered a generation context at all, which the spec records as a presentation event with no grounding event behind it.

The Standards That Sit Underneath: Not Just a Coalition

SPUR is careful to describe itself as an infrastructure project rather than a lobby. That matters, because a coalition that only writes position papers does not change scraping behaviour. What exists today:

AssetWhat it isState as of 19 Nov 2026
Content Telemetry StandardThe five-event schema for reporting AI content usagev1.0, Apache 2.0, 16 GitHub stars, 7 forks
SPUR telemetry profilePublisher profile with a "Compliant" accreditation tier and a conformance markCC-BY-SA-4.0, 5 stars
Cloudflare WorkerEdge worker that detects AI bot access and reports content_retrieved eventsOpen source, TypeScript, uses Cloudflare's verified bot categories
Fastly Compute serviceThe same edge detection for Fastly-hosted sitesOpen source, Apache 2.0
telemetry-py / telemetry-jsPython and TypeScript SDKs for building the reporting documentsZero runtime dependencies
telemetry-serverReference Rust server: ingest, spec validation, session documentsApache 2.0

Across nine public repositories the coalition has roughly 24 stars in total, which is a useful corrective to any impression that this is a widely adopted standard today. It is not. It is a specification that exists, is free to implement, has reference implementations at the edge, and is being written by the people whose content is being used.

The Licensing Advisory Board, announced with version 1.0, is the commercial half. Its membership is by invitation, and it is made up of the organisations building the technical infrastructure that sits between publishers and AI systems. Buttle's stated purpose is to make sure "the technical standards underpinning the market are shaped and agreed by the ecosystem that will run on them, so rights can be verified, use can be measured, permissions honoured, deals can be made without friction."

What This Means If You Publish Your Own Content

Everything above is about what publishers want. The question for a creator is simpler and more awkward: when you publish on X, Bluesky or LinkedIn, what is the equivalent of a telemetry event for your work?

The honest answer is that there isn't one yet, and the reason is structural. Content Telemetry is an inference-time standard. The specification is unusually explicit about the boundary: "Nothing here reports that a model was trained on a work, and a conforming implementation says nothing either way about it." Training crawls can be reported as content_retrieved events with purpose: training, but they are permitted and non-attributable — no session, no grounding, no citation follows them. A retrieval for training looks exactly like a retrieval that nobody used.

For a creator, this produces a three-layer picture:

LayerCovered by Content Telemetry?What you can actually do about it
Training crawls — bulk collection for corpus buildingNo. Reported as a non-attributable retrieval, if the publisher reports at all.Rate limits, bot detection, and blocking at the edge. Not licensing.
Inference fetches — content pulled to answer a live questionYes. All five events apply, with a session ID linking them.Read the telemetry. Correlate it with your own server logs.
Your own posts, wherever they end upOnly if the platform that hosts them chooses to report.Archive them yourself, at publication time.

That third row is the one that matters most for this audience, and it is where the archive still wins. Telemetry is a reporting protocol between a publisher and an AI platform. It does not put a copy of your thread on your disk, and it does not survive the platform that hosts it.

A Reporting-Compliant Archive Workflow

If your work is being fetched and used by AI systems, three things are worth doing, and they compose into one script. Step one is to check whether the site you are reading from even participates. The manifest is plain JSON at a well-known path, and it declares roles, operator identity and the telemetry endpoint to report to. Step two is to send the correlation header, so the publisher's own infrastructure can tie your request to your report. Step three is to keep your own copy — because telemetry reports usage, and reports expire.

These commands are identical across all three language versions of this article, so you can copy them directly:

# 1. Read the publisher's telemetry manifest before you fetch anything
#    Manifests are plain JSON at /.well-known/content-telemetry.json

curl -s "https://example.com/.well-known/content-telemetry.json" \
  -H "Accept: application/json" \
  | python3 -m json.tool

# 2. Send the Content-Telemetry-ID header so the publisher can correlate
#    your retrieval with theirs. One UUID per fetch, reused across redirects.

curl -s "https://example.com/article" \
  -H "Content-Telemetry-ID: 550e8400-e29b-41d4-a716-446655440000" \
  -H "Accept: text/html" \
  -o article.html

Step three is where a creator's own archive comes in, and where the distinction between telemetry and archiving becomes concrete. The purpose field is an open enum with four core values — training, inference, search and advertising — and it classifies the access, not the organisation. The spec notes that inference is where attribution matters most, because there is a user, a query and a session behind the retrieval.

# 3. Report the retrieval you actually made
#    The five events are post-hoc: report what happened, not what you planned.
#    purpose is an open enum: training | inference | search | advertising

curl -s -X POST "https://telemetry.openattribution.org/events" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OA_API_KEY" \
  -d '{
    "type": "content_retrieved",
    "timestamp": "2026-11-19T09:00:00Z",
    "source_role": "agent",
    "content_url": "https://example.com/article",
    "content_id": "example:article-1",
    "purpose": "inference",
    "content_telemetry_id": "550e8400-e29b-41d4-a716-446655440000"
  }'

# 4. Keep your own copy. Telemetry reports usage; it does not archive content.

curl -s "https://threadgrab.com/api/profile/{username}" \
  -H "Accept: application/json" \
  -o ~/archive/{username}-profile.json

Two implementation details are worth copying verbatim from the reference SDK. First, the Content-Telemetry-ID header is a UUID the agent generates per fetch and repeats on its own content_retrieved event. When the publisher's edge or origin also observes the request, it can report the same UUID, and the two observations correlate into a single corroborated event. An uncorroborated retrieval — the publisher saw traffic, but no agent reported it back — is itself a signal: it suggests a scraper that does not support the protocol.

Second, HTTP clients typically do not forward custom headers across redirects. The specification tells agents to re-attach the header on redirect requests to the same domain, and tells publishers who rely on redirect-based routing to instrument the earliest point in the chain rather than only the final origin. If you are building a fetch loop, that is the bug you will hit first.

Where the Standard Stops

It is worth being precise about the edges, because the specification is careful and the marketing around it often is not. Content Telemetry explicitly does not define attribution algorithms, does not mandate a privacy policy, does not require any particular transport, and does not define content access or licensing protocols. It is a reporting layer, and it works with any access protocol or none — the license_ref field connects a telemetry event to whatever licence issued it, but the schemas are independent.

It also does not model agent internals. What happens between retrieval and grounding — the fan-out, the relevance evaluation, the re-ranking, the reasoning chains — is explicitly out of scope. And the coalition is candid that publishing a manifest establishes control of a domain or a path under one, not a legal person: nothing in a manifest binds a domain to an organisation or carries a jurisdiction.

For publishers, SPUR's own members have been building parallel pressure. In September 2026, Condé Nast and Hearst were among roughly 300 media executives backing a federal "bad bots" bill on AI scraping. Blocking, litigation and legislation remain live. Telemetry is the voluntary, contractual lane next to them — and it is the lane that produces evidence rather than a complaint.

FAQ

What is the SPUR Coalition?

SPUR — Standards for Publisher Usage Rights — is a coalition of news publishers formed to shape the technical and commercial conditions under which AI systems use published content. It launched in February 2026 with eight founding members (the BBC, Financial Times, Guardian Media Group, Telegraph Media Group, Sky News, the Associated Press, Mediahuis and CMA Media) and counts more than 80 members across over 20 countries as of November 2026.

Did DMGT block AI crawlers?

No. DMGT joined the board of SPUR, a standards coalition. That is not a blocking action and should not be described as one. SPUR's own stated goal is to make licensing the route for AI models to use copyrighted media, and its main technical output to date is the Content Telemetry Standard, a reporting format rather than an access-control system.

What are the five Content Telemetry events?

content_retrieved (fetched over HTTP), content_grounded (entered the agent's generation context), content_cited (explicitly referenced in the response), content_presented (made perceivable on a recipient-facing surface) and content_engaged (a user clicked, copied, shared or acted). The gaps between consecutive events are what publishers bill and measure against.

Does Content Telemetry report AI training?

No, and the specification says so directly: "Nothing here reports that a model was trained on a work, and a conforming implementation says nothing either way about it." A training crawl can be reported as a content_retrieved event with purpose set to training, but that event is non-attributable — no session, grounding or citation follows it. The standard covers inference-time use.

Is the Content Telemetry Standard free to implement?

Yes. The telemetry specification is published under Apache 2.0 and the publisher profile under CC-BY-SA-4.0, both on public GitHub repositories with reference implementations at the edge (Cloudflare Worker and Fastly Compute), Python and TypeScript SDKs, and a Rust reference server. Adoption is still early, though: the whole coalition's public repositories total roughly 24 GitHub stars.

Do I need to run a telemetry endpoint to archive my own posts?

No, and this is the most common misreading. Telemetry is a protocol between a publisher and an AI platform; it reports usage, it does not archive content. To keep your own copy of what you publish, you need a local capture at publication time. ThreadGrab saves public X threads, Bluesky posts and LinkedIn articles as clean Markdown and JSON, so the archive is a file you own rather than a record you depend on someone else to keep.

Bottom Line

The headline of this story is a publisher joining a board. The story underneath it is that a group of publishers decided the only durable answer to "how is my content being used by AI" is a shared, verifiable measurement standard — and then published it, openly, with reference implementations, before the legal pressure arrived.

That matters for creators for one reason. The three layers above are not equally controllable, and the layer you actually own is your own archive. Content Telemetry tells a publisher what an AI system did with a page. A local Markdown file tells you what you said, when you said it, and it still does not depend on X, Bluesky or LinkedIn keeping the record. Archive at publication time. Report if the platform asks. Those are different jobs, and only one of them is yours to do.

Keep your own copy before the platform decides otherwise

ThreadGrab saves public X threads, Bluesky posts and LinkedIn articles as clean Markdown and JSON, with the capture time attached. One command, portable output, no lock-in.

Try ThreadGrab →

Primary sources