adagents.json Tech Spec
Theadagents.json file provides a standardized way for publishers to declare which sales agents are authorized to sell their advertising inventory. This specification addresses authorization transparency and helps prevent unauthorized reselling of publisher inventory.
File Location
Publishers must host theadagents.json file at:
File Format
The file must be valid JSON with UTF-8 encoding and return HTTP 200 status.Basic Structure
Schema Definition
$schema(optional): JSON Schema reference for validationcontact(optional): Contact info for entity managing this filename(required): Name of managing entity (may be publisher or third-party)email(optional): Contact email for questions/issuesdomain(optional): Primary domain of managing entityseller_id(optional): Seller ID from IAB Tech Lab sellers.jsontag_id(optional): TAG Certified Against Fraud ID
properties(optional): Array of properties covered by this file (same structure aslist_authorized_properties)tags(optional): Metadata for property tags (same structure aslist_authorized_properties)authorized_agents(required): Array of authorized sales agentsurl(required): Agent’s API endpoint URLauthorized_for(required): Human-readable authorization descriptionproperty_tags(optional): Tags identifying which properties this agent represents (resolved against top-levelproperties)properties(optional): Explicit property list (alternative toproperty_tags)
last_updated(optional): ISO 8601 timestamp of last modification
Contact Information
The optionalcontact object identifies who manages this adagents.json file - which may be the publisher themselves or a third-party operator.
Why this matters: If there are questions or issues with authorization, buyers know who to contact. This also enables cross-validation with sellers.json and TAG certification.
email, domain, and seller_id when available to facilitate verification and communication.
Property Declaration
The optionalproperties array lists all properties covered by this file, using the same structure as list_authorized_properties.
Key insight: adagents.json and list_authorized_properties should be consistent - they describe the same properties with the same tags.
Agent Authorization Patterns
Agents can be authorized using property IDs (recommended), tags (for flexible grouping), or explicit property lists.Pattern 1: Property IDs (Recommended)
Useproperty_ids to reference specific properties by ID - direct and unambiguous.
property_id values.
Pattern 2: Tag-Based Authorization
Useproperty_tags to reference properties by tag - good for flexible grouping.
tags includes "meta_network".
Pattern 3: Explicit Property Objects
Useproperties array for inline property definitions (rare - usually properties are defined at top level).
Pattern 4: Publisher Property References
Usepublisher_properties to authorize an agent for properties defined in another publisher’s adagents.json file. This is the recommended pattern when publishers authorize third-party sales agents, as it ensures a single source of truth for property definitions.
By Property ID:
- Agent references properties from the publisher’s canonical
adagents.jsonfile - Property IDs and tags are resolved against the publisher’s properties/tags definitions
- Ensures consistency - if publisher updates properties, agent authorization automatically reflects changes
- When buyer agents call
list_authorized_properties, they should fetch each referenced publisher’sadagents.jsonto resolve property definitions
Pattern 5: No Scoping (Simple Case)
Ifproperty_ids, property_tags, properties, and publisher_properties are all omitted, agent is authorized for ALL properties in this file.
Real-World Examples
Example 1: Meta Network (Tag-Based)
Meta manages Instagram, Facebook, and WhatsApp with a single sales agent. This adagents.json would be hosted at meta.com/.well-known/adagents.json (or instagram.com, facebook.com, whatsapp.com - all would have the same content). Note:publisher_domain is optional in adagents.json when properties are for the same domain where the file is hosted. It’s included here because these are cross-domain properties (Instagram, Facebook, WhatsApp) all managed by Meta.
Example 2: Tumblr (Subdomain Exclusion)
Tumblr authorizes sales only for corporate properties, NOT user blogs. This file would be hosted at tumblr.com/.well-known/adagents.json. Note:publisher_domain is omitted since the property is for the same domain where the file is hosted (tumblr.com).
"value": "tumblr.com" (not "*.tumblr.com"), so the agent is authorized ONLY for the root domain. User blogs on subdomains like userblog.tumblr.com are not authorized.
Example 3: CNN (Channel and Geographic Segmentation)
CNN has CTV properties managed by one agent, and US/international websites by another:Mobile Applications
Mobile applications follow the same pattern as app-ads.txt:- Developer Website: Apps reference their developer’s website through app store listings
- Single File: Publisher hosts one
adagents.jsonfor all properties (websites, apps, etc.) - Trust Chain: App store enforces developer website link, creating trusted authorization path
- Property Scoping: Use the
propertiesarray to specify which apps/platforms each agent represents
Implementation for Apps
Publishers with mobile apps can use property scoping to specify which platforms each agent represents:Examples
Minimal Configuration
Publisher with Full Metadata
Multiple Agents with Different Specializations
DOOH Network with Portfolio Discovery
Crawling and Discovery
Crawler Requirements
- Frequency: Crawlers should fetch
adagents.jsonevery 24 hours - User Agents: Follow standard web crawler practices and respect robots.txt
- Caching: Cache responses for up to 24 hours unless
last_updatedindicates changes - Validation: Validate against JSON schema before processing
Robots.txt Compatibility
Ensureadagents.json is not blocked in robots.txt:
Integration with AdCP
Agent Discovery Process
- Publisher Discovery: Agent discovers publisher domain from media buy request
- Fetch Authorization: Request
/.well-known/adagents.jsonfrom publisher domain - Validate Authorization: Confirm agent URL appears in
authorized_agentsarray - Cache Results: Cache authorization for 24 hours with periodic refresh
Validation Flow
Error Handling
- File Not Found (404): Agent proceeds without authorization validation
- Invalid JSON: Agent rejects request as unauthorized
- Schema Validation Failure: Agent rejects request as unauthorized
- Agent Not Listed: Agent rejects request as unauthorized
Buyer Agent Validation
Buyer agents MUST validate sales agent authorization before purchasing inventory to prevent unauthorized reselling.Validation Process
When receiving aget_products response, buyer agents should:
- Extract Properties: Get the
propertiesarray from each product - Check Each Domain: For each property, fetch
/.well-known/adagents.jsonfrom the domain - Validate Agent Authorization: Confirm the sales agent URL appears in
authorized_agents - Match Authorization Scope: Compare
authorized_fordescription with product details - Reject Unauthorized: Decline products from unauthorized agents
Required Product Schema
Products MUST include aproperties array with comprehensive property identification:
Property Types and Identifiers
Website Properties
Mobile App Properties
CTV/OTT App Properties
DOOH Properties
Podcast Properties
Tags for Scale
Tags enable efficient management of large property portfolios:- Network Membership:
yahoo_network,disney_network,conde_nast_network - Content Categories:
news,sports,entertainment,gaming,lifestyle - Quality Indicators:
premium_content,brand_safe,viewability_certified - Geographic:
us_national,nyc_dma,tier_1_markets - Technical:
gdpr_compliant,coppa_compliant,header_bidding_enabled
Validation Examples
✅ Authorized Sale
Product from agent@salescompany.com:❌ Unauthorized Resale
Product from agent@unauthorizedreseller.com:⚠️ Scope Mismatch
Product from agent@videospecialist.com:Enhanced Validation Examples
CTV App Validation
Product with Multiple CTV Platform IDs:newsnetwork.com/.well-known/adagents.json
Mobile App Validation
Product with Multiple Platform Identifiers:gamecompany.com/.well-known/adagents.json
DOOH Network Validation
Product with Venue and Screen IDs:clearchannel.com/.well-known/adagents.json
Podcast Validation
Product with Multiple Podcast Platform IDs:newsnetwork.com/.well-known/adagents.json
Implementation Requirements
Buyer agents MUST implement the following validation logic:1. Property-Level Validation
For each property in theproperties array:
- Extract the
publisher_domainfield - Fetch
/.well-known/adagents.jsonfrom that domain - Validate sales agent authorization
2. Identifier-Based Validation
For websites, also validate domain identifiers:3. Tag-Based Efficiency (Optional Future Enhancement)
Publishers may eventually support tag-based authorization:4. Multi-Property Validation
- Validate all properties in the array
- Reject if any property fails authorization
- Cache results per publisher domain to avoid repeated requests
5. Required Validation Steps
- Extract Properties: Parse the enhanced
propertiesarray structure - Check Publisher Domains: Fetch adagents.json from each
publisher_domain - Validate Domain Identifiers: For website properties, check each domain identifier
- Match Authorization Scope: Compare
authorized_forwith product details - Handle Property Types: Different validation logic per
property_type - Cache Efficiently: Cache by publisher domain, not individual properties
- Log Results: Track authorization status for debugging and reporting
Error Handling
- Missing adagents.json: Continue with warning (file may not exist yet)
- Invalid JSON: Treat as authorization failure
- Agent Not Listed: Reject as unauthorized resale
- Scope Mismatch: Flag for manual review or reject based on policy
- Network Errors: Retry with exponential backoff, treat repeated failures as warnings
Domain Matching Rules
For website properties with domain identifiers, AdCP follows web conventions for common subdomains while requiring explicit authorization for others.Base Domain Matching (example.com)
Base domain format matches the domain plus standard web subdomains:
Example: "value": "cnn.com" authorizes:
- ✅
cnn.com - ✅
www.cnn.com(standard web subdomain) - ✅
m.cnn.com(standard mobile subdomain) - ❌
edition.cnn.com(requires explicit authorization) - ❌
money.cnn.com(requires explicit authorization)
Specific Subdomain Matching (subdomain.example.com)
Specific subdomain matches only that exact subdomain:
Example: "value": "edition.cnn.com" authorizes:
- ✅
edition.cnn.com - ❌
cnn.com - ❌
www.cnn.com - ❌ Any other subdomain
Wildcard Subdomain Matching (*.example.com)
Wildcard format matches ALL subdomains but NOT the base domain:
Example: "value": "*.cnn.com" authorizes:
- ✅
www.cnn.com - ✅
m.cnn.com - ✅
edition.cnn.com - ✅
money.cnn.com - ✅ Any subdomain
- ❌
cnn.com(base domain requires separate authorization)
Common Patterns
Pattern 1: Base Domain (Most Common)
cnn.com, www.cnn.com, and m.cnn.com
Pattern 2: Base + Specific Subdomains
Pattern 3: All Subdomains (Use with Caution)
Validation Process
When validating domain authorization:- Extract Domain Identifiers: Get all
domaintype identifiers from the property - Apply Matching Rules: For each domain identifier, determine which domains it matches
- Check Authorization: Fetch
/.well-known/adagents.jsonfrom each matched domain - Verify Agent: Confirm the selling agent appears in each domain’s authorized agents list
Security Considerations
File Integrity
- HTTPS Required: Always serve over HTTPS to prevent tampering
- Regular Updates: Update
last_updatedtimestamp when making changes - Backup Copies: Maintain backup of authorization file
Authorization Granularity
Theauthorized_for field allows publishers to specify:
- Geographic restrictions: “US and CA only”, “EMEA region”
- Inventory types: “display inventory”, “video placements”, “native ads”
- Relationship types: “direct sales”, “authorized reseller”
- Platform specifications: “mobile apps”, “desktop web”, “CTV”
- Format specializations: “premium video”, “rewarded ads”, “interstitials”
Comparison to ads.txt
| Feature | ads.txt | app-ads.txt | adagents.json |
|---|---|---|---|
| Format | CSV-like text | CSV-like text | JSON |
| Location | /ads.txt | /app-ads.txt | /.well-known/adagents.json |
| Structure | Fixed 4-field format | Fixed 4-field format | Extensible JSON schema |
| Validation | Manual parsing | Manual parsing | JSON Schema validation |
| Mobile Apps | Not supported | Supported | Supported |
| Scope | Publisher-level | Publisher-level | Publisher-level |
| Metadata | Limited | Limited | Rich descriptions |
| Extensibility | None | None | Schema versioning |
Best Practices
- Keep Updated: Regularly review and update authorized agents
- Be Specific: Use detailed
authorized_fordescriptions that clearly define scope - Monitor Access: Track who accesses the file via web logs
- Schema Validation: Validate file against JSON schema before publishing
- Backup Strategy: Maintain backups of authorization configuration
- Clear Authorization: Ensure
authorized_fordescriptions are actionable and specific
Schema Validation
Option 1: Web-Based Manager (Recommended)
Use the AdAgents.json Manager for the easiest validation experience:- ✅ Validates your live domain’s adagents.json file
- ✅ Checks agent card endpoints automatically
- ✅ Provides detailed error messages and warnings
- ✅ Creates properly formatted files with guided input
- ✅ No installation required
- Visit adcontextprotocol.org/adagents
- Enter your domain name
- Get instant validation results with actionable feedback
Option 2: Command Line
Validate youradagents.json file using the JSON schema:
Implementation Checklist
- Create
adagents.jsonwith required fields (use the AdAgents Manager for guided creation) - Use clear, specific
authorized_fordescriptions - Host at
/.well-known/adagents.jsonon your domain - Validate against JSON schema (use AdAgents Manager or ajv-cli)
- Ensure HTTPS serving with HTTP 200 response
- Configure robots.txt to allow crawling
- Test agent discovery process
- Verify agent cards are accessible (automatic in AdAgents Manager)
- Set up monitoring for file accessibility
- Document authorization policies for your team
- Plan regular review schedule for authorized agents
Future Considerations
This v1 specification focuses on publisher-level authorization for simplicity and broad adoption. Future versions may add:- Fine-grained app or property-specific authorization
- Integration with emerging app identification standards
- Enhanced metadata for programmatic buying