Agent Access Model

Humans browse free. AI agents pay.

ToolHund is an AI tool decision layer. People can use every page, comparison and recommendation for free — forever. Machines that consume our structured decision data programmatically (agents, copilots, LLM apps, RAG pipelines) run on metered access.

Humans

$0

Unlimited browsing, comparisons, rankings and recommendations. No account, no key.

AI agents

3 free calls / day

Then HTTP 402 Payment Required with machine-readable pricing at /api/v1/agent-access.

Free vs paid

Paid responses are self-serve and need no approval. Bulk resale or model training needs a separate data license. Vendor prices are public facts; you pay for checked, structured, filterable data.

FeatureFreePaid (1 API call; $5 / 1,000 via Stripe)
Price-change headlines + official source linkYes — /api/v1/news, /feed.xml (previews, no amounts)Yes
Before/after amount, currency, billing period, confidenceNoYes — Market Pulse
Filters (tools, event type), cursors, 30-day historyCounts onlyYes
Wording/format-only editsHiddenNever reported as price changes
Decision coverage (which tools can be ranked)Yes — /api/v1/decision/coverage—
Ranked pick + price comparison with evidenceRanked slugs onlyYes — /api/v1/decision
Limitsrecommend 20/day per IP · agent endpoints 3/day · coverage 30/minPulse 60/min · Decision 20/min per IP
MCPFree previews onlyPaid results over REST, never over MCP
AI Tool Decision API

A sourced tool pick your agent can cite

Send a task, a monthly budget and up to 8 candidate tools. You get a ranked pick and a plan-by-plan pricing comparison, with the official pricing URL and the date we last checked it. Tools without a recent successful check are listed as excluded, never guessed. The ranking is a transparent rule (budget fit, feature keywords, entry price), not a benchmark. Pricing pages are re-checked daily for a small set of tools (a few dozen currently have fresh evidence), so many requests will return exclusions or a 422 — which is never charged.

  • Free preview
    Ranked tool names only.
  • 1 API call per result
    Key bought by card with Stripe. No account.
  • $5 per 1,000 calls
    One-time Stripe pack; monthly plans too.
POST https://toolhund.com/api/v1/decision
{"task":"grammar and tone checks for work emails","budget_usd_month":20,"candidates":["grammarly","jasper","rytr"]}
Market Pulse API

Recent AI tool price changes, in one call

A feed of the last 1–30 days: detected price changes on official pricing pages, tools newly added to the catalog, and latest pricing-verification snapshots (one per tool, not every past check). Only about 60 tools are price-watched automatically, and the pricing check runs once a day, so this is a narrow, dated signal — not full market coverage.

  • Free preview
    Counts by type plus one redacted item.
  • 1 API call per request
    Key bought by card with Stripe. No account.
  • $5 per 1,000 calls
    One-time Stripe pack; monthly plans too.
GET https://toolhund.com/api/v1/pulse?event_type=price_change&tools=notion,canva&limit=50
# newest first; page older events with next_cursor (while has_more):
GET https://toolhund.com/api/v1/pulse?cursor=<next_cursor>
# later, poll only newer events with poll_cursor (then its next_cursor):
GET https://toolhund.com/api/v1/pulse?cursor=<poll_cursor>

A query that matches nothing returns a free empty result — nothing is charged. Bad filters and outages are never charged either.

Buy 1,000 calls — $5

Quickstart: free check → paid call

Buy a key by card with Stripe ($5 for 1,000 calls, no account), then send Authorization: Bearer th_live_…. One paid answer uses one call. We no longer accept crypto payments.

// 1) Buy a key once (card, Stripe): $5 for 1,000 calls, no account.
//    GET https://toolhund.com/api/public/api-buy?plan=credits_1k&format=json
//    -> open checkout_url, pay, then GET key_delivery_url -> { api_key }
const KEY = process.env.TOOLHUND_API_KEY; // th_live_… — never commit it

// 2) Free check first (never charged):
const cov = await fetch("https://toolhund.com/api/v1/decision/coverage?candidates=grammarly,jasper");
console.log(await cov.json());

// 3) Paid call: one request uses one call from the key's quota.
const res = await fetch("https://toolhund.com/api/v1/pulse?event_type=price_change", {
  headers: { authorization: `Bearer ${KEY}` },
});
if (res.status === 402) console.log("stripe_checkout_required:", (await res.json()).checkout_url);
else {
  const feed = await res.json();
  console.log(feed.data.length, feed.poll_cursor); // store poll_cursor to fetch only newer events later
}

// Decision: POST https://toolhund.com/api/v1/decision  {"task":"...","candidates":["a","b"]}
// with the same Authorization header. 400/422/429/503 and empty results are never charged.

Python (requests / httpx)

A 403 from the hosting edge is not a payment request, so don’t retry. 402 means you need a key, 400 invalid input, 422 not enough evidence or query too wide, and 429 wait for Retry-After. None of these are charged.

# pip install requests   (or httpx; same calls). Keep the library's own User-Agent.
# Note: bare urllib is currently refused at the hosting edge (HTTP 403 "error code: 1010").
import os, requests

BASE = "https://toolhund.com"
KEY = os.environ["TOOLHUND_API_KEY"]  # bought at /api/public/api-buy?plan=credits_1k (Stripe)

def classify(r):
    if r.status_code == 403:
        code = " (error code 1010)" if "1010" in r.text else ""
        raise SystemExit(f"Edge/hosting block{code} — not a payment request. Do not retry.")
    if r.status_code == 400: raise SystemExit(f"Invalid input: {r.text}")
    if r.status_code == 402: raise SystemExit("Buy a key: " + r.json()["checkout_url"])
    if r.status_code == 422: raise SystemExit("Not enough evidence / query too wide (not charged).")
    if r.status_code == 429: raise SystemExit("Rate limited; wait for Retry-After (not charged).")
    r.raise_for_status()
    return r.json()

print(classify(requests.get(f"{BASE}/api/v1/decision/coverage", params={"candidates": "grammarly,jasper"})))
feed = classify(requests.get(f"{BASE}/api/v1/pulse", params={"event_type": "price_change"},
                             headers={"Authorization": f"Bearer {KEY}"}))
print(len(feed["data"]), feed.get("poll_cursor"))

Metered agent plans

Buy 1,000 calls once — $5

Developer

$49/mo

10,000 agent calls / month

$4.90 per 1,000 calls

  • Recommend, search, compare & pricing endpoints
  • MCP server access
  • 60 requests / minute
  • Email support

Startup

$149/mo

50,000 agent calls / month

$2.98 per 1,000 calls

  • Everything in Developer
  • 300 requests / minute
  • Affiliate revenue share on agent-driven conversions
  • Attribution reporting

Business

$499/mo

250,000 agent calls / month

$2.00 per 1,000 calls

  • Everything in Startup
  • Bulk feeds + nightly data dumps
  • Uptime SLA & dedicated support
  • Custom ranking filters

How the meter works

  1. Every request is classified: human browser vs. agent/bot client.
  2. Agents get 3 free calls per UTC day to evaluate the data.
  3. After that, agent requests return 402 with plans, prices and a buy URL — so an autonomous agent can surface the upgrade to its operator.
  4. Licensed keys (Authorization: Bearer th_live_…) bypass the meter and run on plan limits.

Need bulk training data or RAG indexing instead? See data licensing. Want placement in agent answers? See sponsorships.