Know when AI
uses your content
Track how AI agents use your content. Free, open source telemetry operated by an independent standards body.
One session, four events
When an AI agent retrieves your content, that is an event. When it loads your content into its working context, that is a second - the grounding event, where your content starts creating value. When it cites your content in a response, that is a third. When a user clicks through, that is a fourth.
We built the infrastructure to capture them. We operate it for free. This is what it looks like.
{
"version": "0.1",
"telemetry_endpoint": "https://api.openattribution.org/v1",
"domain": "example.com",
"org_id": "org_abc123"
}Your domain. Our infrastructure.
This file tells AI agents and your own infrastructure where to send usage data.
It sits at your domain's .well-known path - the same pattern used for SSL verification and security policies.
The endpoint points to OA's telemetry server - purpose-built, privacy-first, free to use. We handle collection, storage, and aggregation. Your CDN or server middleware reports retrieval events there. Cooperative agents check the file to find it. You see the results.
Want a closed loop? The server is open source (Apache 2.0) - you can self-host and point the file at your own infrastructure. But for most domains, the OA endpoint is the fastest way to get visibility.
The file is simple to publish. The work behind it - getting AI platforms, browsers, and marketplaces to respect it - is what OpenAttribution exists to do.
We generate the file. You host it. Free.
Open standard. Your data.
What happens when AI uses your content
Your infrastructure already sees AI bot traffic. The standard gives it structure so you can track, measure, and act on it.
Step 1 of 6
A user asks an AI agent a question
Someone opens ChatGPT, Perplexity, a shopping assistant - any agentic interface. They type a question. The agent needs to answer, and to answer well, it needs content.
Your content is retrieved
Works today - no agent cooperation needed
The agent fetches your article, your review, your product page. Your CDN or web server sees the request and reports it. You detect the AI user agent, emit a structured event, done. This works with any bot that visits your site - whether it cooperates with the standard or not.
{
"type": "content_retrieved",
"content_url": "https://example.com/best-headphones",
"source_role": "origin",
"timestamp": "2026-01-15T10:30:01Z"
}Your content enters the agent's context
Requires agent adoption - the standard's core goal
The agent loads your article into its working context. This is the grounding event - the moment your content starts creating value. An agent might fetch 30 articles but only load 3 into context. The other 27 were retrieved but never used. Grounding captures the boundary that matters: what actually influenced the response.
Content cached by the agent for days still produces a grounding event in every session it influences, even when your CDN sees nothing. This is the invisible middle - where content creates value without credit. Today, it is unmeasurable. Grounding makes it visible.
{
"type": "content_grounded",
"content_url": "https://example.com/best-headphones",
"data": {
"scope": "session",
"cached": false,
"tokens_ingested": 4200
}
}Your content is cited in the response
The agent paraphrases your review, quotes your comparison, references your data. Not all grounded content gets cited - content can influence every response in a session without receiving credit once. The gap between grounding and citation is where the interesting questions live.
{
"type": "content_cited",
"content_url": "https://example.com/best-headphones",
"data": {
"citation_type": "paraphrase",
"excerpt_tokens": 85,
"position": "primary"
}
}Events flow to your telemetry endpoint
Retrieval events from your infrastructure, grounding and citation events from cooperative agents - they all flow to the endpoint
declared in your .well-known/openattribution file.
The OA public server collects them for free, or you self-host. Your data either way.
Content owners get visibility
Which AI bots are hitting your site? How often? Which pages? That's what you can see today with server-side reporting.
As agent adoption grows, the picture fills in - which agents are grounding your content, which are citing it, in what form, how prominently. The grounding-to-citation ratio tells you how much of your content's influence goes uncredited. That's the data that makes licensing conversations real instead of guesswork.
It starts with seeing the retrieval. The standard is how we get to the rest.
See what's happening
Whether you're a publisher, a brand, or a retailer - if you have content on the web, AI agents are using it. Free tools to see it happening. Open standards to do something about it.
Check your domain with PolicyCheck
Check your domain with PolicyCheck
See which of 26+ AI bots can access your content right now. No signup needed. Takes 30 seconds.
Try PolicyCheckSee which of 26+ AI bots can access your content right now. No signup needed. Takes 30 seconds.
Try PolicyCheckStart tracking with a .well-known file
Start tracking with a .well-known file
We generate your .well-known/openattribution file.
Place it on your site - four lines of JSON that declare your telemetry endpoint.
Publishing this file costs nothing and positions you for the cooperative future.
We generate your .well-known/openattribution file.
Place it on your site - four lines of JSON that declare your telemetry endpoint.
Publishing this file costs nothing and positions you for the cooperative future.
Report AI bot traffic from your stack
Report AI bot traffic from your stack
Your infrastructure already sees every AI bot request. Pick your platform - a short integration detects AI user agents and reports retrieval events to your telemetry endpoint. You don't need AI companies to cooperate. Events go to the OA public server by default, or route them to your own.
Only bot identity (user agent) and URL visited. No cookies, no user data, no impression tracking.
Your infrastructure already sees every AI bot request. Pick your platform - a short integration detects AI user agents and reports retrieval events to your telemetry endpoint. You don't need AI companies to cooperate. Events go to the OA public server by default, or route them to your own.
Only bot identity (user agent) and URL visited. No cookies, no user data, no impression tracking.
Add web server middleware
Add web server middleware
Origin-side reporting for Express, Django, Rails. Catches the OA-Telemetry-ID header
from cooperative agents and reports corroborated retrieval events. When both your server and the agent report the same fetch,
you get a stronger signal than either alone.
Origin-side reporting for Express, Django, Rails. Catches the OA-Telemetry-ID header
from cooperative agents and reports corroborated retrieval events. When both your server and the agent report the same fetch,
you get a stronger signal than either alone.
Host your own telemetry server
Host your own telemetry server
The reference server is open source (Apache 2.0). Deploy it yourself and own the full pipeline - collection, storage, reporting. Point your .well-known file at your own endpoint and every signal routes to infrastructure you control. No third-party dependency. No data leaving your network. The protocol is the same either way.
Reference server on GitHubThe reference server is open source (Apache 2.0). Deploy it yourself and own the full pipeline - collection, storage, reporting. Point your .well-known file at your own endpoint and every signal routes to infrastructure you control. No third-party dependency. No data leaving your network. The protocol is the same either way.
Reference server on GitHubBuilding an agent?
Register for an API key and your agent can report the full event lifecycle - retrieval, grounding, citation, engagement. Publishers already see retrieval from their own infrastructure. Agent-side reporting adds the events only you can observe - starting with grounding, which captures the moment content enters your generation context. CDNs and content marketplaces are moving toward requiring agents to declare attribution intent before granting access. Get ahead of it.
This takes collective action
No single publisher, brand, or technology provider can solve the attribution challenge alone. The standards defined now will shape the content economy for the next decade. Early participants shape those standards.
Publishers
Your content powers AI systems that capture your traffic. Without measurement, there is no basis for negotiation.
Brands
Your product information powers AI shopping recommendations. You currently have no visibility into how it is represented.
Tech providers
Attribution infrastructure is the next frontier. CDNs, analytics platforms, and commerce tools all need this layer.
AI platforms
Transparency solves the content access problem. Negotiate once with coalitions, not individually with every publisher.
OpenAttribution is a not-for-profit standards body, not a vendor. Open governance. One member, one vote.
Join the initiativeDeveloper quick start
Two paths into telemetry. Publishers report retrieval from their own infrastructure - no agent cooperation needed. Agent developers register for an API key and report the full event lifecycle - retrieval, grounding, citation, engagement.
Publisher-side telemetry Your CDN or origin detects AI agents and reports retrieval. Uses your domain API key.
pip install openattribution-telemetry
from openattribution.telemetry import Client
async with Client(
endpoint="https://telemetry.openattribution.org/v1",
) as client:
session_id = await client.start_session(
content_scope="shopping-assistant",
)
await client.record_event(
session_id=session_id,
event_type="content_retrieved",
content_url="https://example.com/article",
)
await client.record_event(
session_id=session_id,
event_type="content_cited",
content_url="https://example.com/article",
)Agent-side telemetry Your agent reports retrieval, grounding, citation, and engagement. Requires registration for an API key.
pip install openattribution-telemetry
from openattribution.telemetry import Client
async with Client(
endpoint="https://api.openattribution.org/v1",
api_key="oa_your_key_here",
) as client:
session_id = await client.start_session(
initiator_type="agent",
agent_id="my-research-agent",
)
await client.record_event(
session_id=session_id,
event_type="content_retrieved",
content_url="https://example.com/article",
)
await client.record_event(
session_id=session_id,
event_type="content_grounded",
content_url="https://example.com/article",
data={"scope": "session", "tokens_ingested": 4200},
)
await client.record_event(
session_id=session_id,
event_type="content_cited",
content_url="https://example.com/article",
)Where OpenAttribution fits
OpenAttribution doesn't replace licensing standards - it completes the picture. Publishers declare what AI can do with their content. We provide the identity and measurement to verify it's happening.
| Standard | The question it answers | Side |
|---|---|---|
| Source-side licensing RSL, IAB CoMP, Peek-Then-Pay | What can AI do with this content? | Publisher |
| AIMS Agent identity + licensed sources | Who is this AI and what can it access? | Agent |
| Telemetry Content attribution events | What did this AI actually do with the content? | Behaviour |
Compatible with any source-side licensing standard. Publishers define permissions. OpenAttribution provides the audit trail.
Open by design
Shaped by the people who use it. Building common ground between content owners and AI - so the relationship runs on transparency, not conflict.
Where we are today
How it's governed
Apache 2.0 licensed
Every specification, SDK, and reference server. Open source, free to use, modify, and distribute.
Not-for-profit
No shareholders. No dividends. Surplus reinvests into the mission. Accounts filed publicly.
One member, one vote
Membership fees fund operations, not influence. A mid-size publisher has the same voting power as a big tech company. Technical decisions are made by a Technical Steering Committee guided by the mission, not the money.
2026 roadmap
Founding membership confirmed, steering committee established, governance formalised
Organising documents ratified, standard framework agreed, legal and operational foundations set
Roundtable working groups live, attribution standards defined with direct AI platform input
Research published on AI content usage patterns, attribution implementations underway across members
FAQ
What if AI agents ignore the standard?
That's precisely why server-side and CDN reporting exist. You don't need the agent to cooperate. Your infrastructure can detect AI user agents and report retrieval events regardless. When an agent does cooperate, you get corroborated events - stronger signal, not a dependency.
How is this different from GEO?
Generative engine optimisation is probabilistic - you guess how content influences AI responses based on ranking signals and heuristics. OpenAttribution is deterministic - you observe the actual events. Today that means retrieval events from your own infrastructure. As agents adopt the standard, you get citation events too - which content was used, how, and how prominently. It's the difference between estimating TV ad impact and watching the transaction happen.
Is this opposed to AI development?
No. AI systems need quality content. Content owners need measurement and attribution. These standards make both possible without requiring either party to trust the other blindly. The agents who participate get better content access. The ones who don't still get tracked at the infrastructure level.
Why an open standard instead of a product?
Attribution only works if both sides of the transaction trust the data. A proprietary intermediary taking a cut on every interaction creates the wrong incentives. An open protocol that anyone can implement - and anyone can verify - creates the right ones. Think DNS, not an analytics vendor. The protocol is the value. Companies building attribution products, content marketplaces, and licensing platforms can all build on the same telemetry layer instead of each inventing their own.
What does it cost?
Nothing. The specifications, SDKs, and reference server are Apache 2.0 - free to use, modify, distribute. OpenAttribution is a not-for-profit standards body, not a vendor. No transaction fees. No data fees. Claiming your domain is free. The public telemetry server is free. Self-hosting is free. The protocol is the same either way.
Get involved
Join the publishers, brands, and technology providers shaping how content attribution works in AI.