Specification · CC-BY-4.0

PriceFeed v1.0.0

One JSON file at a well-known location. That is the entire standard. Everything else — validation, signing, resolving — is infrastructure we run so you don't have to.

status: stable published 2026-10-01 governance: Ginkgo Foundation json-schema available

01 · Getting started

Adoption is deliberately boring. If your service has a price, you can publish a feed in under ten minutes:

Create a JSON file following this spec — twenty lines covers most services.
Host it at https://yourdomain.com/.well-known/agent.price.json with Content-Type: application/json and permissive CORS.
That's it. The registry crawler finds new feeds via DNS sweep and referral; you can also submit the URL manually in the vendor console.

Design rule #1 — the feed is data, not code. No executable content, no redirects through trackers, no per-request pricing. Dynamic prices belong in your API; the feed points to them.

02 · The feed

A minimal, complete feed:

agent.price.json — minimal

{
  "$schema": "https://ginkgo.dev/schema/v1/feed.json",
  "feed_version": "1.0.0",
  "publisher": {
    "id": "acme-compute",
    "name": "Acme Compute",
    "domain": "acme.dev"
  },
  "services": [{
    "sku": "h100-spot",
    "name": "H100 SXM spot",
    "category": "gpu_cloud",
    "pricing": {
      "model": "per_gpu_hour",
      "unit_price_usd": 1.98,
      "billing_granularity": "second",
      "spot_available": true
    },
    "regions": ["us-east", "eu-west"],
    "payment": { "methods": ["x402", "card"] },
    "purchase": { "action": "https://acme.dev/signup", "api_provisioning": true }
  }]
}

Pricing models currently recognized: per_gpu_hour, per_million_tokens, per_second, per_request, per_gb_month, flat_subscription. Propose new ones via governance.

03 · Field reference

service.pricing

field	type		notes
model	enum	REQ	One of the recognized pricing models. Determines how resolvers compare you.
unit_price_usd	number	REQ	USD, pre-tax. Micro-pricing down to 6 decimals is valid ($0.000003).
billing_granularity	enum	REQ	`second · minute · hour · token · request · month`
spot_available	bool	OPT	Spot/interruptible capacity flag. Agents filter on this heavily.
free_tier	object	OPT	`{ "quota": 1000000, "unit": "tokens", "period": "month" }`
volume_tiers	array	OPT	Ascending breakpoints; resolver interpolates effective price at requested volume.

service.sla & service.limits

field	type		notes
sla.uptime_pct	number	OPT	Self-reported; verified vendors get this cross-checked against probes.
sla.support_tier	string	OPT	`community · business · 24/7 · dedicated`
limits.min_commit	string	OPT	Minimum contract. "none" is a ranking advantage.
limits.quota_increase	string	OPT	`self-serve · ticket · sales-call` — agents strongly prefer self-serve.

04 · Discovery

Feeds live at a fixed well-known path so agents and crawlers never guess:

well-known location

# the only rule that matters
GET https://{domain}/.well-known/agent.price.json

# required headers on the response
Content-Type: application/json
Access-Control-Allow-Origin: *
Cache-Control: max-age=300

Subdomains are independent: api.acme.dev and acme.dev may publish different feeds. Redirects are followed at most once, and only within the same registrable domain.

Why not DNS TXT records? Size. A feed with ten SKUs blows past TXT practical limits, and HTTPS gives us TLS identity for free during verification.

05 · Verification

Anyone can publish a feed. Verified feeds additionally prove control of the domain and sign every snapshot:

Domain proof — serve a one-time challenge at /.well-known/ginkgo-challenge.txt or set a DNS TXT record.
Feed signature — sign the canonical JSON with ed25519; publish the key fingerprint in the feed. The registry countersigns after human review.
Probe cross-check — for compute feeds, we run probe workloads monthly and compare billed vs. published price. Divergence > 2% flags the feed.

Verified feeds get the green badge, ranking priority in the resolver, and inclusion in the monthly vendor report. Verification is a paid service; the standard itself stays free forever.

06 · Resolver API

The read path of the whole system. Stateless, edge-cached, free under 10k calls/day.

request

GET https://resolver.ginkgo.dev/v1/resolve
    ?intent=gpu_inference
    &gpu=h100
    &max_price=2.50
    &region=us-east
    &payment=x402
    &rank=match
    &limit=4

param	type	notes
intent	enum	`gpu_inference · llm_api · fine_tuning · embedding · storage · data_api` — new verticals ship behind the same param.
max_price	number	In the feed's native unit for that pricing model (e.g. $/GPU-hr, $/Mtok).
rank	enum	`match · price · sla`. `match` blends price rank, SLA, and verification status.
provenance	bool	Set `1` to include the raw feed excerpt for every result — useful for audit trails.

Try it live in the playground — the playground on this site calls the same code path agents do.

07 · MCP server

For agent frameworks, the resolver is wrapped as three MCP tools:

mcp — tools

price.resolve(intent, constraints)  → ranked candidates
price.feed(domain)                  → full feed for one vendor
price.compare(skus[], workload)   → total-cost projection

Install: npx @ginkgo/mcp-server · or point your framework at https://mcp.ginkgo.dev/sse.

08 · Versioning & governance

The spec is semantically versioned. feed_version declares what you publish against; resolvers accept any 1.x feed indefinitely. Breaking changes go through a public RFC window of 90 days, and every deprecated field keeps working for 24 months.

The standard is stewarded by the Ginkgo Foundation — vendor seats are capped at one per company, and no single company may hold a majority.
All schemas, validators and the reference crawler are open source (Apache-2.0).
Registered pricing models and categories are append-only. Nobody's feed ever silently breaks.

The promise — if the foundation ever disappears, the spec, the schema history and the registry snapshot are public domain. Your feeds keep working; anyone can stand up a resolver.