UADP
Universal Agentic Data Protocol
A protocol that gives AI agents direct, structured access to service data — no HTML scraping, no browser automation, no guessing. Just typed JSON that agents can reason over.
The problem with HTML for agents
Every website on the internet was built for human eyes. The data you actually care about — your balance, your inbox, your order status — is buried inside HTML templates, React components, and JavaScript that runs only in a browser runtime. Agents cannot use any of that efficiently.
The current state of the art is browser automation: agents spin up a Chromium instance, navigate to a URL, wait for JavaScript to render, parse the DOM, and hope the layout hasn't changed since the last time someone updated the adapter. It's slow, it's brittle, and it fails silently.
UADP solves this at the protocol level. Instead of agents reading pages, services expose data. Instead of scraping, agents query. Instead of layout-dependent parsing, agents receive typed schema objects.
UADP in 60 seconds
Autodiscovery
A service publishes /.well-known/uadp.json. Astral finds it, parses the manifest, and knows what data is available — before the agent asks anything.
Typed schema
52 canonical types across 10 categories. Every uadp:transaction has the same guaranteed fields. Agents don't adapt per-service — they read the schema.
Signed tokens
Requests are signed with your passkey. The service validates the signature. No passwords transit the network. Your private key never leaves your device.
What the protocol defines
Autodiscovery — /.well-known/uadp.json
Any service that supports UADP publishes a manifest at a well-known path. Astral fetches this on first contact. No manual configuration required.
/* /.well-known/uadp.json */
{
"version": "1.0",
"service": "example-bank",
"endpoints": {
"transactions": "/uadp/v1/transactions",
"accounts": "/uadp/v1/accounts",
"balance": "/uadp/v1/balance"
},
"schema_types": ["uadp:transaction", "uadp:account", "uadp:balance"],
"auth": {
"type": "passkey",
"challenge_endpoint": "/uadp/v1/auth/challenge"
},
"ai_hints": {
"primary_use": "financial overview and transaction history",
"pagination": "cursor-based"
}
} Schema registry — 10 categories, 52 types
Every UADP object carries guaranteed base fields: uadp_type, id, ts, label, ext. Service-specific fields live in ext.* namespaces.
ai_hints — context for agents, not users
UADP manifests and responses include an ai_hints field — free-form guidance written for the agent, not displayed to the user. Hints describe how to paginate, what actions are common, what data is stale, and what the agent should prioritize.
/* ai_hints on a uadp:transaction response */
"ai_hints": {
"summary": "User's primary checking account. High-frequency transactions.",
"stale_after": "PT5M",
"common_actions": ["filter_by_merchant", "export_csv", "flag_unusual"]
} Graceful degradation — scraping adapters
Services that don't natively speak UADP are handled by scraping adapters: YAML-configured normalizers that extract data from HTML and map it to the appropriate schema types. The agent always receives a typed UADP object. Native UADP support is always preferred; adapters are the practical bridge while adoption grows.
Why agents need a protocol
The history of the web is a history of protocols: HTTP for transport, HTML for documents, CSS for style. Each protocol solved a coordination problem — it gave publishers and browsers a shared contract so either side could evolve independently.
The agentic web needs the same thing. Without UADP, every AI agent team builds its own scraping layer for every service, and those layers break every time a service updates its layout. With UADP, services expose a stable API, agents consume a typed schema, and both sides can evolve independently.
This is the same bet the web made in 1994: standardize the protocol, let the ecosystem grow on top. UADP is that bet for agents. Explore the spec and implementation at github.com/joseespana/uadp-protocol.
Frequently asked questions
What is UADP?
UADP (Universal Agentic Data Protocol) is an open protocol that lets services expose their data as structured JSON instead of HTML. AI agents query UADP endpoints directly, receiving typed objects they can reason over and act on — no HTML parsing required.
How does UADP autodiscovery work?
A service publishes a manifest at /.well-known/uadp.json describing its endpoints, supported schema types, and authentication requirements. Astral's UADP client fetches this manifest on first contact and caches it. The agent then knows exactly what data the service can provide.
What happens if a service doesn't support UADP?
Astral includes scraping adapters — YAML-configured normalizers that parse a service's HTML and map it to the appropriate UADP schema types. The agent always receives structured data, even from non-native UADP services. Native support is always preferable; adapters are the fallback.
Is UADP open source?
Yes. The protocol specification and reference implementation are available on GitHub at github.com/joseespana/uadp-protocol. Any service can implement UADP endpoints without licensing fees.
How does authentication work with UADP?
UADP uses passkey-signed tokens. When you authenticate, your device signs a challenge using a private key that never leaves the hardware (Secure Enclave, TPM, or StrongBox). The resulting token is attached to UADP requests. Services validate the token without ever seeing your credentials.
Talk to an agent that speaks UADP
Astral's agent works on UADP-enabled data. Ask it anything about your connected services.