# AgentBIT — full tool documentation for AI agents

> Pay-per-call API tools over the x402 protocol (v2). No signup, no API keys: POST to any endpoint, receive HTTP 402 with base64 payment requirements in the PAYMENT-REQUIRED header, sign an EIP-3009 USDC authorization for the exact amount, retry with the X-PAYMENT header. First call is FREE for new wallets on tools priced <= $0.02. Volume discounts advertised in every 402 envelope.

## How to pay (once, applies to every tool)
1. `POST https://agentbit.app{path}` with your JSON body and no payment → HTTP 402. Decode the base64 `PAYMENT-REQUIRED` response header: it lists accepts[] with network (CAIP-2), maxAmountRequired (atomic USDC units), payTo, asset and extra.name (the EIP-712 domain name to sign with — use it verbatim).
2. Sign an EIP-3009 transferWithAuthorization for exactly that amount and retry with `X-PAYMENT: <base64 payload>`. If the server advertised `extensions`, echo them in your payload.
3. Easiest path: `npm i x402-fetch-pay` then `payAndCall(url, {json}, {privateKey})` — handles the whole loop. MCP clients: connect to https://agentbit.app/mcp and pass `_payment`. Full quickstart: https://agentbit.app/start

## Free operations (no payment)
- `GET https://agentbit.app/api/discover?q=...` — search 8k+ indexed x402 resources across the whole ecosystem.
- MCP operation `agentbit_discover` — same engine over https://agentbit.app/mcp.

## Tools

### x402 Ecosystem Discovery (`discover`)
- Endpoint: `POST https://agentbit.app/v1/x402/discover` — 0.001 USDC per call
- Category: ai
- Aggregated discovery for the x402 ecosystem. AgentBIT continuously scans the public Coinbase Bazaar, the Agent402 index and the Agentic Market API, deduplicates resources by URL and enriches them with historical usage metrics (settled calls, unique buyers, USD volume) and per-source freshness. One symbolic-price call replaces querying three registries. Filters: category, network (CAIP-2), source, max_price; sorting by price, volume, calls or recency. The same search is free over plain HTTP at /api/discover — this x402 endpoint exists so payment-native agents can use it in-band and discover it in the Bazaar itself.
- Input fields:
  - `query` (string, required) — What you are looking for (matched against name, description, URL)
  - `category` (string, optional)
  - `network` (string, optional) — CAIP-2, e.g. eip155:8453
  - `source` (string, optional)
  - `max_price` (number, optional) — Maximum price in USDC
  - `sort` (string, optional)
  - `limit` (integer, optional) — Max results (default 25, max 100)
- Example request: `{"query":"web search","sort":"volume","limit":5}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/x402/discover -H 'Content-Type: application/json' -d '{"query":"web search","sort":"volume","limit":5}'`

### LEI / Company Identity (`business-identity`)
- Endpoint: `POST https://agentbit.app/v1/business/identity` — 0.003 USDC per call
- Category: business
- LEI lookups, global company identity search and identifier validation via GLEIF.
- Input fields:
  - `operation` (string, required)
  - `lei` (string, optional)
  - `company_name` (string, optional)
- Example request: `{"operation":"lei_lookup","lei":"5493001KJTIIGC8Y1R12"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/business/identity -H 'Content-Type: application/json' -d '{"operation":"lei_lookup","lei":"5493001KJTIIGC8Y1R12"}'`

### Company Enrichment (`company-enrich`)
- Endpoint: `POST https://agentbit.app/v1/company/enrich` — 0.1 USDC per call
- Category: business
- Enrich a company from its domain: name, description, technologies, social profiles, mail infrastructure.
- Input fields:
  - `domain` (string, optional)
  - `company_name` (string, optional)
- Example request: `{"domain":"stripe.com"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/company/enrich -H 'Content-Type: application/json' -d '{"domain":"stripe.com"}'`

### Company Research Dossier (`company-research`)
- Endpoint: `POST https://agentbit.app/v1/company/research` — 0.1 USDC per call
- Category: business
- Composed dossier: company enrichment + web search + news + website signals + risk indicators in one normalized response.
- Input fields:
  - `domain` (string, optional)
  - `company_name` (string, optional)
- Example request: `{"domain":"stripe.com"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/company/research -H 'Content-Type: application/json' -d '{"domain":"stripe.com"}'`

### EU VAT Validation (`vat-check`)
- Endpoint: `POST https://agentbit.app/v1/compliance/vat` — 0.02 USDC per call
- Category: compliance
- Live EU VAT validation for invoicing, onboarding and compliance workflows. The number is checked against VIES — the European Commission's official cross-border VAT information exchange system — which queries the member state's real register: a valid answer means the trader is registered for intra-EU transactions RIGHT NOW, and where the member state publishes them you also get the registered trader name and address to match against what your counterparty claimed. Accepts the number in any common shape ('RO12345678', 'ro 123-456.78', or country and number as separate fields); Greece's EL prefix and Northern Ireland's XI are handled. Member-state outages (a VIES reality) are reported as retryable errors, never as false negatives, and an invalid answer explains that some states have domestic-only registrations that VIES does not cover. Reverse-charge B2B invoicing inside the EU requires exactly this check — agents issuing invoices should run it before every new counterparty.
- Input fields:
  - `vat_number` (string, required) — VAT number, with or without the country prefix, e.g. RO12345678
  - `country` (string, optional) — Two-letter member state code if not included in vat_number (EL for Greece, XI for Northern Ireland)
- Example request: `{"vat_number":"RO14399840"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/compliance/vat -H 'Content-Type: application/json' -d '{"vat_number":"RO14399840"}'`

### Academic Paper Search (`paper-search`)
- Endpoint: `POST https://agentbit.app/v1/research/papers` — 0.01 USDC per call
- Category: data
- Academic paper search built for AI agents doing real research. One paid call queries three authoritative open scholarly indexes simultaneously — OpenAlex (250M+ works with citation counts and open-access resolution), Crossref (the DOI registry) and arXiv (preprints with guaranteed PDFs) — then merges and deduplicates the results by DOI and title. Each paper returns: title, up to 12 authors, publication year, venue, DOI, citation count (richest source wins), a reconstructed abstract where available, the canonical URL, and — the part agents actually need — a direct open-access pdf_url when a legal free full text exists, so the next step (fetch and read the paper) is one HTTP GET away. Filters: limit (1-25), year_from, open_access_only. Set format to 'bibtex' to also get a ready-to-use BibTeX entry per paper. Per-source status is reported so you can see exactly which indexes answered. Data comes from public scholarly APIs; citation counts and OA links are as fresh as the sources themselves.
- Input fields:
  - `query` (string, required) — Search query: topic, title fragment, or author + topic (3-300 chars)
  - `limit` (integer, optional) — Max papers to return (1-25, default 10)
  - `year_from` (integer, optional) — Only papers published in or after this year
  - `open_access_only` (boolean, optional) — Only papers with a direct open-access PDF link
  - `format` (string, optional) — 'bibtex' adds a ready-to-cite BibTeX entry per paper
- Example request: `{"query":"attention is all you need transformer","limit":5,"format":"bibtex"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/research/papers -H 'Content-Type: application/json' -d '{"query":"attention is all you need transformer","limit":5,"format":"bibtex"}'`

### Wallet Counterparties (`wallet-counterparties`)
- Endpoint: `POST https://agentbit.app/v1/wallet/counterparties` — 0.01 USDC per call
- Category: data
- Relationship mapping for any Base address. The wallet's most recent native transactions (up to ~100, two explorer pages) are aggregated per counterparty into a ranked list: counterparty address, explorer-known name where one exists (exchanges, labeled protocols), number of interactions split into sent/received, total native value moved, first and last time seen in the sample, and up to 5 distinct methods used with that counterparty. Use it to see whether a wallet mostly talks to a DEX, a bridge, an exchange deposit address or a fixed set of private wallets — a strong prior when deciding to transact. Honest scope, stated in the output: this is a recent-activity sample from public explorer data, not a complete historical graph, and token-transfer-only relationships may not appear. Completes the AgentBIT wallet-intelligence shelf with wallet-screen, wallet-profile and wallet-transactions.
- Input fields:
  - `address` (string, required) — EVM address on Base (0x + 40 hex)
  - `top` (integer, optional) — Max counterparties to return (1-25, default 10)
- Example request: `{"address":"0x4395C7e383b7e05665aad7f36ed77c01923Dd965","top":5}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/wallet/counterparties -H 'Content-Type: application/json' -d '{"address":"0x4395C7e383b7e05665aad7f36ed77c01923Dd965","top":5}'`

### Wallet Profile (`wallet-profile`)
- Endpoint: `POST https://agentbit.app/v1/wallet/profile` — 0.01 USDC per call
- Category: data
- Wallet profiling for agents that need to know who they are dealing with — or size up any address on Base. One call combines public RPC state (native ETH balance, nonce, account type including EIP-7702 delegated EOAs with the delegate address) with Blockscout enrichment: total transaction count, up to 25 ERC-20 token holdings sorted by USD value (amount + USD where the explorer knows a price, with an honest truncation flag), explorer presence and public tags. Comparable proprietary wallet profilers charge $0.01 per endpoint and split this across several calls; this returns the profile in one call at $0.01 from open data. Part of the AgentBIT wallet-intelligence shelf: wallet-screen (sanctions + risk), wallet-profile (state), wallet-transactions (history), wallet-counterparties (relationships).
- Input fields:
  - `address` (string, required) — EVM address on Base (0x + 40 hex)
- Example request: `{"address":"0x4395C7e383b7e05665aad7f36ed77c01923Dd965"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/wallet/profile -H 'Content-Type: application/json' -d '{"address":"0x4395C7e383b7e05665aad7f36ed77c01923Dd965"}'`

### Wallet Transactions (`wallet-transactions`)
- Endpoint: `POST https://agentbit.app/v1/wallet/transactions` — 0.01 USDC per call
- Category: data
- Recent transaction history for any Base address, cleaned up for machine consumption. Each transaction returns: hash, direction relative to the queried wallet (in/out), the counterparty address plus its explorer-known name where one exists (exchanges, protocols, labeled contracts), native ETH value, the decoded method name where the ABI is known (transfer, swap, approve...), success status, fee paid and timestamp — newest first, up to 50 per call. Built for agents that vet counterparties before paying them, reconcile expected vs actual payments, or watch an address for activity. Data comes from the public Base explorer; token-transfer-only activity (no native tx) may not appear, and the output says so. Pairs with wallet-profile (current state), wallet-counterparties (aggregated relationships) and wallet-screen (sanctions + risk).
- Input fields:
  - `address` (string, required) — EVM address on Base (0x + 40 hex)
  - `limit` (integer, optional) — Max transactions to return (1-50, default 20)
- Example request: `{"address":"0x4395C7e383b7e05665aad7f36ed77c01923Dd965","limit":10}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/wallet/transactions -H 'Content-Type: application/json' -d '{"address":"0x4395C7e383b7e05665aad7f36ed77c01923Dd965","limit":10}'`

### Weather Forecast (`weather`)
- Endpoint: `POST https://agentbit.app/v1/data/weather` — 0.002 USDC per call
- Category: data
- Global weather for agents, from MET Norway's Locationforecast — the official API of the Norwegian Meteorological Institute (the model behind yr.no), free for commercial use with proper identification and attribution, both of which this tool handles. Give it lat/lon (coordinates, not place names — pair with your own geocoding) and get: current conditions (temperature °C, wind m/s, humidity, precipitation next hour, condition code like 'partlycloudy_day'), a condensed hourly forecast for the next 1-48 hours, and a decision-ready summary: min/max temperature, total expected precipitation and a will_rain boolean. Responses are cached per rounded location for 30 minutes per MET's terms, so repeated checks are instant. Comparable x402 weather feeds have dozens of paying buyers — this one runs on official meteorological model data with zero markup pressure.
- Input fields:
  - `lat` (number, required) — Latitude -90..90
  - `lon` (number, required) — Longitude -180..180
  - `hours` (integer, optional) — Hourly entries to return (1-48, default 24)
- Example request: `{"lat":46.7712,"lon":23.6236,"hours":12}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/data/weather -H 'Content-Type: application/json' -d '{"lat":46.7712,"lon":23.6236,"hours":12}'`

### Wikipedia Facts (`wiki-facts`)
- Endpoint: `POST https://agentbit.app/v1/knowledge/wiki` — 0.005 USDC per call
- Category: data
- Entity grounding for AI agents. Before reasoning about a person, company, place, technology or event, an agent needs a reliable baseline — this tool provides it in one call: a Wikipedia search returning up to 10 ranked matches (title, one-line description, canonical URL), plus the full summary of the best match with its extract (up to 2000 characters), thumbnail image and last-modified timestamp, so you can see how fresh the article is. Works across 300+ Wikipedia language editions via the lang parameter (en, ro, de, ja...). Disambiguation pages are identifiable by their type field. Uses the official Wikimedia REST APIs with proper identification, and returns the CC BY-SA attribution note your agent must carry when republishing content. Pairs naturally with paper-search (academic sources) and web-search (current web) as the encyclopedic layer of a research stack.
- Input fields:
  - `query` (string, required) — Entity or topic to look up (2-300 chars)
  - `lang` (string, optional) — Wikipedia language edition (default en)
  - `limit` (integer, optional) — Max search matches (1-10, default 5)
- Example request: `{"query":"EIP-3009","lang":"en"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/knowledge/wiki -H 'Content-Type: application/json' -d '{"query":"EIP-3009","lang":"en"}'`

### x402 Envelope Inspector (`x402-inspect`)
- Endpoint: `POST https://agentbit.app/v1/x402/inspect` — 0.001 USDC per call
- Category: developer
- The x402 debugger we wished existed when we launched. Give it a paid endpoint URL and it probes it with GET, decodes the PAYMENT-REQUIRED envelope and lints every accepts[] entry against the x402 v2 spec AND against how the CDP facilitator and Coinbase Bazaar behave in production: CAIP-2 network ids (plain 'base' breaks v2 clients), maxAmountRequired as an atomic-unit string (a float there breaks signing), payTo/asset address formats, scheme support (the public CDP facilitator settles only 'exact'), description quality (Bazaar ranking depends on it), timeout sanity, and the killer nobody documents loudly enough — extra.name must equal the token contract's EIP-712 domain name, which for USDC is 'USD Coin' on Base mainnet but 'USDC' on Base Sepolia; get it wrong and every single settlement fails with an invalid signature. Alternatively paste a base64 PAYMENT-REQUIRED header to lint offline, or a PAYMENT-SIGNATURE payload to check the client side: EIP-3009 authorization completeness, expired validBefore, payTo/value mismatches, and whether the server's advertised extensions were echoed back — the silent omission that makes the facilitator settle happily while Bazaar never indexes the resource. Findings return as error/warning/info, each explaining what will break in practice. At $0.001, run it in CI on every deploy of a paid endpoint.
- Input fields:
  - `url` (string, optional) — A paid x402 endpoint to probe live (GET, expects the 402 envelope)
  - `payment_required` (string, optional) — Base64 PAYMENT-REQUIRED header value to lint offline
  - `payment_payload` (string, optional) — Base64 PAYMENT-SIGNATURE header value to lint the client payload (optionally alongside payment_required)
- Example request: `{"url":"https://agentbit.app/v1/web/search"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/x402/inspect -H 'Content-Type: application/json' -d '{"url":"https://agentbit.app/v1/web/search"}'`

### DeFi Yield Search (`defi-yields`)
- Endpoint: `POST https://agentbit.app/v1/defi/yields` — 0.002 USDC per call
- Category: finance
- DeFi yield screening for agents that allocate capital. One call searches the full DefiLlama yield universe (thousands of pools across every major chain, pre-filtered to TVL ≥ $50k so answers stay meaningful) with the filters that matter: chain (base, ethereum, arbitrum...), project (aave, morpho, aerodrome...), token symbol (USDC, ETH...), stablecoins_only for the risk-averse, and min_tvl_usd (default $100k) to skip ghost pools. Results rank by APY and carry the decomposition an allocator needs: total APY, base vs reward split (reward-heavy APY = emissions that can vanish), TVL and impermanent-loss risk flag. The pool set is cached server-side and refreshed every 15 minutes, so queries are fast. Includes the honest disclaimer: high APY usually means high risk, figures change constantly, not financial advice. Pairs with stablecoin-stats (peg check before entering a stable pool) and protocol-tvl (how big is the protocol behind the pool).
- Input fields:
  - `chain` (string, optional) — Filter by chain, e.g. base, ethereum, arbitrum
  - `project` (string, optional) — Filter by protocol, e.g. aave-v3, morpho
  - `symbol` (string, optional) — Filter by token symbol substring, e.g. USDC
  - `stablecoins_only` (boolean, optional) — Only stablecoin pools
  - `min_tvl_usd` (number, optional) — Minimum pool TVL (default 100000)
  - `limit` (integer, optional) — Max pools returned (1-50, default 15)
- Example request: `{"chain":"base","symbol":"USDC","stablecoins_only":true,"limit":5}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/defi/yields -H 'Content-Type: application/json' -d '{"chain":"base","symbol":"USDC","stablecoins_only":true,"limit":5}'`

### Invoice / IBAN Intelligence (`financial-document`)
- Endpoint: `POST https://agentbit.app/v1/financial-document/intelligence` — 0.02 USDC per call
- Category: finance
- IBAN validation and repair, VAT format validation, invoice extraction operations.
- Input fields:
  - `operation` (string, required)
  - `iban` (string, optional)
  - `vat` (string, optional)
- Example request: `{"operation":"iban_validate","iban":"RO49AAAA1B31007593840000"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/financial-document/intelligence -H 'Content-Type: application/json' -d '{"operation":"iban_validate","iban":"RO49AAAA1B31007593840000"}'`

### FX Aggregator (`fx`)
- Endpoint: `POST https://agentbit.app/v1/finance/fx` — 0.005 USDC per call
- Category: finance
- Live foreign exchange rates (mid/bid/ask) for currency pairs with source attribution.
- Input fields:
  - `pairs` (array, required)
- Example request: `{"pairs":["EUR/USD","EUR/RON"]}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/finance/fx -H 'Content-Type: application/json' -d '{"pairs":["EUR/USD","EUR/RON"]}'`

### Protocol TVL & Fundamentals (`protocol-tvl`)
- Endpoint: `POST https://agentbit.app/v1/defi/protocol` — 0.002 USDC per call
- Category: finance
- Protocol due diligence for agents interacting with DeFi. Look up any protocol by name or slug fragment ('aave', 'uniswap', 'morpho') and get the fundamentals that size counterparty risk: current TVL in USD, 1-day and 7-day TVL change (a sudden drain is the loudest on-chain alarm), category (Lending, DEX, Bridge...), the chains it is deployed on and its website. Or screen: filter the whole tracked universe by category and/or chain, ranked by TVL — 'top lending protocols on Base' is one call. Protocols under $10k TVL are excluded to keep answers meaningful. Data is DefiLlama's open protocols API, cached server-side and refreshed every 15 minutes. Pairs with defi-yields (which pool) and token-risk (is the protocol's token safe).
- Input fields:
  - `protocol` (string, optional) — Protocol name or slug fragment, e.g. aave
  - `category` (string, optional) — Filter by category, e.g. lending, dexes, bridge
  - `chain` (string, optional) — Filter to protocols deployed on this chain, e.g. base
  - `limit` (integer, optional) — Max results (1-50, default 10)
- Example request: `{"category":"lending","chain":"base","limit":5}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/defi/protocol -H 'Content-Type: application/json' -d '{"category":"lending","chain":"base","limit":5}'`

### Stablecoin Stats & Peg Monitor (`stablecoin-stats`)
- Endpoint: `POST https://agentbit.app/v1/defi/stablecoins` — 0.002 USDC per call
- Category: finance
- Stablecoin monitoring for the agent economy — where every payment IS a stablecoin. Returns the tracked stablecoin universe (circulating supply ≥ $1M) ranked by market cap, each with: name, symbol, peg type and mechanism (fiat-backed, crypto-backed, algorithmic — the risk hierarchy), circulating USD, current price and the computed peg_deviation_percent ((price−1)×100 for USD pegs; positive above peg, negative below). Two modes: look up specific coins by symbol (USDC, USDT, DAI), or DEPEG SCREENING — set max_peg_deviation_percent and get only coins whose absolute deviation is at least that value, the early-warning check an agent should run before accepting or holding a settlement currency. Data from DefiLlama's open stablecoins API, cached server-side and refreshed every 10 minutes. Pairs with token-price (any token) and fx (fiat rates).
- Input fields:
  - `symbol` (string, optional) — Filter by symbol substring, e.g. USDC
  - `max_peg_deviation_percent` (number, optional) — Depeg screen: only coins with ABSOLUTE deviation >= this value (e.g. 0.5)
  - `limit` (integer, optional) — Max results (1-50, default 15)
- Example request: `{"symbol":"USDC"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/defi/stablecoins -H 'Content-Type: application/json' -d '{"symbol":"USDC"}'`

### Token Price (`token-price`)
- Endpoint: `POST https://agentbit.app/v1/defi/price` — 0.002 USDC per call
- Category: finance
- Token price lookup built for high-frequency agent use. Ask for up to 10 tokens in one call, addressed exactly how agents hold them: <chain>:<contract-address> for anything on Base, Ethereum, Arbitrum, Optimism, Polygon, Solana and 100+ other chains, or coingecko:<id> for majors (coingecko:ethereum, coingecko:bitcoin). Each answer carries the aggregated USD price, symbol, decimals, a CONFIDENCE score (how solid the price source mix is — thin DEX-only pricing scores lower) and the price timestamp, with unknown tokens listed separately in missing[] instead of failing the whole call. Source is DefiLlama's open price engine, which aggregates DEX and CEX sources. At $0.002 per call (first call free for new wallets, volume discounts advertised in every 402), it is priced to be called before every trade decision. Pairs with token-risk (is this token safe?) and stablecoin-stats (is my settlement currency on peg?).
- Input fields:
  - `token` (string, optional) — Single token: <chain>:<address> or coingecko:<id>
  - `tokens` (array, optional) — Up to 10 tokens per call
- Example request: `{"tokens":["base:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913","coingecko:ethereum"]}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/defi/price -H 'Content-Type: application/json' -d '{"tokens":["base:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913","coingecko:ethereum"]}'`

### DNS Inspector (`dns-inspect`)
- Endpoint: `POST https://agentbit.app/v1/dns/inspect` — 0.01 USDC per call
- Category: infrastructure
- DNS inspection for agents auditing infrastructure, deliverability and counterparties. One call resolves all the record types that matter (A, AAAA, MX, TXT, NS, CNAME, SOA, CAA — or the subset you ask for) through Cloudflare's public DNS-over-HTTPS resolver, returning each record with its TTL. On top of the raw records it computes an email security posture: SPF record present and its all-policy (~all vs -all), DMARC record fetched from _dmarc.<domain> with its p= policy, MX count, and a one-word assessment (enforced / monitoring-only / partial / unprotected). CAA records show which CAs may issue certificates. Use it before trusting mail from a domain, when diagnosing deliverability, or as the DNS layer of a counterparty check alongside domain-intel and counterparty-risk.
- Input fields:
  - `domain` (string, required) — Hostname to inspect, e.g. example.com
  - `types` (array, optional) — Record types to query (default: all eight)
- Example request: `{"domain":"example.com","types":["A","MX","TXT"]}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/dns/inspect -H 'Content-Type: application/json' -d '{"domain":"example.com","types":["A","MX","TXT"]}'`

### Endpoint Monitor (`endpoint-monitor`)
- Endpoint: `POST https://agentbit.app/v1/monitor/endpoint` — 0.005 USDC per call
- Category: infrastructure
- Endpoint monitoring built for agents that watch services — their own, or the APIs they depend on. One call performs a full health probe: HTTP status and whether the service counts as up, end-to-end latency in milliseconds, response size, server and content-type headers. For HTTPS endpoints it opens a TLS connection with certificate capture and reports the issuer, subject, SANs, expiry timestamp and days remaining — catching expiring certificates two weeks out. A security-header audit checks HSTS, Content-Security-Policy, X-Content-Type-Options and X-Frame-Options. Problems come back as named issues: UNREACHABLE, SERVER_ERROR_STATUS, SLOW_RESPONSE (>3s), CERTIFICATE_EXPIRING (<14 days), CERTIFICATE_EXPIRED. At $0.005 per probe, an agent checking a service every 5 minutes spends about $1.44/day for full uptime + certificate monitoring with no subscription. All probing is SSRF-guarded and server-side.
- Input fields:
  - `url` (string, required) — Absolute http(s) URL to probe
- Example request: `{"url":"https://agentbit.app/api/health"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/monitor/endpoint -H 'Content-Type: application/json' -d '{"url":"https://agentbit.app/api/health"}'`

### x402 Market Intelligence (`x402-intelligence`)
- Endpoint: `POST https://agentbit.app/v1/x402/intelligence` — 0.02 USDC per call
- Category: research
- Search, trending, seller, category, competition and opportunity data for the x402 tools market.
- Input fields:
  - `operation` (string, required)
  - `q` (string, optional)
  - `seller` (string, optional)
  - `category` (string, optional)
- Example request: `{"operation":"competition","q":"web search"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/x402/intelligence -H 'Content-Type: application/json' -d '{"operation":"competition","q":"web search"}'`

### Counterparty Risk (`counterparty-risk`)
- Endpoint: `POST https://agentbit.app/v1/risk/counterparty` — 0.05 USDC per call
- Category: security
- Technical risk screening of a company, domain or wallet: identity, DNS, SSL, domain age, reachability.
- Input fields:
  - `subject` (string, required)
  - `subject_type` (string, optional)
- Example request: `{"subject":"example.com","subject_type":"domain"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/risk/counterparty -H 'Content-Type: application/json' -d '{"subject":"example.com","subject_type":"domain"}'`

### Domain Intelligence (`domain-intel`)
- Endpoint: `POST https://agentbit.app/v1/domain/intel` — 0.02 USDC per call
- Category: security
- Domain intelligence for agents verifying counterparties, links and sellers. One call queries RDAP — the structured, official registry protocol that replaced WHOIS — through the IANA bootstrap, so answers come from the authoritative registry for each TLD. Returns: registration date and computed age in days (newly-registered domains are the #1 phishing signal), expiry date and days remaining, registrar of record, EPP status codes (hold statuses flagged), nameservers, DNSSEC delegation status. A 404 from the registry is returned as available:true — making this a domain-availability check too. Risk scoring: NEWLY_REGISTERED under 30 days, RECENTLY_REGISTERED under 180, HOLD_STATUS, EXPIRING_SOON, NO_NAMESERVERS, with DNSSEC as a positive signal. Some registries redact fields per policy; the tool reports exactly what the registry publishes. Pairs with counterparty-risk (web posture) and dns-inspect (live DNS).
- Input fields:
  - `domain` (string, required) — Bare registrable domain, e.g. example.com (no scheme, no path)
- Example request: `{"domain":"coinbase.com"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/domain/intel -H 'Content-Type: application/json' -d '{"domain":"coinbase.com"}'`

### Email Deliverability (`email-deliverability`)
- Endpoint: `POST https://agentbit.app/v1/email/deliverability` — 0.03 USDC per call
- Category: security
- Score email deliverability: syntax, domain, MX, SPF, DMARC, disposable detection, role accounts.
- Input fields:
  - `email` (string, required)
- Example request: `{"email":"hello@example.com"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/email/deliverability -H 'Content-Type: application/json' -d '{"email":"hello@example.com"}'`

### IP Intelligence (`ip-intel`)
- Endpoint: `POST https://agentbit.app/v1/ip/intel` — 0.01 USDC per call
- Category: security
- IP intelligence for agents that see client addresses, verify infrastructure or investigate abuse. One call combines: ASN and the network holder's name (who actually operates this address space), the announced BGP prefix, the RIR-registered country of the address block, the registered abuse contact (where to report bad traffic), and reverse DNS via DNS-over-HTTPS. Private and reserved ranges are detected locally and answered instantly without touching the network. Data comes from RIPEstat — the RIPE NCC's official public data API covering all five regional registries — so answers reflect registry records rather than commercial geolocation heuristics; the country is the block's registration location, not a device geolocation, and the output says so honestly. IPv4 and IPv6. Pairs with dns-inspect and domain-intel for a complete infrastructure picture.
- Input fields:
  - `ip` (string, required) — IPv4 or IPv6 address
- Example request: `{"ip":"1.1.1.1"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/ip/intel -H 'Content-Type: application/json' -d '{"ip":"1.1.1.1"}'`

### Sanctions Screening (`sanctions-screen`)
- Endpoint: `POST https://agentbit.app/v1/compliance/sanctions` — 0.02 USDC per call
- Category: security
- Sanctions screening for AI agents and compliance workflows. Checks a name against the OFAC Specially Designated Nationals (SDN) list published by the US Treasury and the UN Security Council consolidated sanctions list, refreshed daily from the official public sources. Matching combines exact normalized comparison, token-subset matching (name order and middle names) and character-level similarity (transliteration variants), returning scored matches with list source, sanctions programs, entity type and country. Use it before onboarding a counterparty, sending a payment, or signing a contract. Results are automated name-similarity screening, not identity verification: matches require human review, and a clear result is not legal or compliance advice.
- Input fields:
  - `name` (string, required) — Person or organization name to screen
  - `threshold` (number, optional) — Minimum similarity score 0.5-1.0 (default 0.75)
  - `limit` (integer, optional) — Max matches to return (default 10, max 25)
- Example request: `{"name":"Example Trading LLC","threshold":0.8}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/compliance/sanctions -H 'Content-Type: application/json' -d '{"name":"Example Trading LLC","threshold":0.8}'`

### Token Risk Audit (`token-risk`)
- Endpoint: `POST https://agentbit.app/v1/risk/token` — 0.02 USDC per call
- Category: security
- ERC-20 token risk audit for AI agents, bots and DeFi workflows on Base. One call answers 'how risky does this token look?' from public data: the token's on-chain interface (name, symbol, decimals, total supply read directly via RPC), contract verification status and proxy/upgradeability from Blockscout, whether ownership has been renounced (owner() live-read — an owner-controlled token can often mint, pause or change rules), holder count and top-holder concentration (excluding burn addresses; a token where one wallet holds most of the supply can be dumped at will), malicious public tags (phishing/scam/exploit), current USD price where known, and an exact-match sanctions screen of the contract address against the OFAC SDN digital-currency address list and UN consolidated list held locally and refreshed daily. Output is a 0-100 risk score, a clear/review/high verdict and named flags explaining every point. Honest scope: this is a static and market-structure analysis, not a honeypot/trade simulation — a clear result is not proof of legitimacy and a flag is not proof of wrongdoing. Not financial, legal or compliance advice.
- Input fields:
  - `address` (string, required) — ERC-20 token CONTRACT address on Base (0x + 40 hex)
- Example request: `{"address":"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/risk/token -H 'Content-Type: application/json' -d '{"address":"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"}'`

### URL Threat Check (`url-threat-check`)
- Endpoint: `POST https://agentbit.app/v1/security/url-threat` — 0.01 USDC per call
- Category: security
- URL threat screening for agents that click links. Layer 1 — structural heuristics that catch most commodity phishing: IP-literal hosts, punycode/homoglyph hosts (xn--), embedded credentials (user@host tricks), plain-http, known URL shorteners, deep subdomain nesting, excessive length or percent-encoding. Layer 2 — a safe server-side redirect trace: the URL is followed hop by hop (max 5) with SSRF protection at every step and no body execution, reporting each hop's status and flagging redirects that land on a different host than they started (URLs whose redirect chain dives into private network space are flagged hard). Layer 3 — when a free abuse.ch Auth-Key is configured, the URL is checked against URLhaus, the live malware-distribution database; a listing raises the score to high with the threat type and reference link. Output is a 0-100 risk score, clear/review/high verdict and named flags. Honest scope: this is heuristic and public-threat-data screening, not sandbox detonation — a clear result is not proof of safety.
- Input fields:
  - `url` (string, required) — Absolute http(s) URL to screen
- Example request: `{"url":"https://bit.ly/3example"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/security/url-threat -H 'Content-Type: application/json' -d '{"url":"https://bit.ly/3example"}'`

### Wallet Screening (`wallet-screen`)
- Endpoint: `POST https://agentbit.app/v1/compliance/wallet-screen` — 0.02 USDC per call
- Category: security
- Pre-transaction wallet screening for AI agents and compliance workflows. Every x402 payment involves a counterparty wallet — this tool answers 'is it safe to transact with this address?' in one call. Sanctions layer: the address is matched exactly against the digital-currency addresses published on the OFAC Specially Designated Nationals list (US Treasury) and the UN Security Council consolidated list, refreshed daily from the official sources and matched locally (deterministic, fast, any chain's address format). On-chain layer (EVM addresses): public Base RPC and Blockscout data — EOA vs contract, contract verification status, nonce and transaction count, native balance, explorer presence and public tags (phishing/scam/exploit tags raise the score sharply). Output is a 0-100 risk score, a clear/review/high verdict and named flags explaining every point of the score. A sanctioned match returns high/100 immediately. Screening uses public data only: a clear result is not proof of legitimacy, a flag is not proof of wrongdoing, and high-value decisions require human review.
- Input fields:
  - `address` (string, required) — Wallet address to screen. EVM addresses (0x + 40 hex) get full on-chain signals; any chain's address format is checked against the sanctions lists.
- Example request: `{"address":"0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/compliance/wallet-screen -H 'Content-Type: application/json' -d '{"address":"0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"}'`

### Reddit Search (`reddit-search`)
- Endpoint: `POST https://agentbit.app/v1/social/reddit/search` — 0.02 USDC per call
- Category: social
- Search Reddit posts by query, subreddit, sort order and timeframe.
- Input fields:
  - `query` (string, required)
  - `subreddit` (string, optional)
  - `sort` (string, optional)
  - `timeframe` (string, optional)
  - `limit` (integer, optional)
- Example request: `{"query":"laravel 13","limit":3,"sort":"new"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/social/reddit/search -H 'Content-Type: application/json' -d '{"query":"laravel 13","limit":3,"sort":"new"}'`

### Utility Transform (`util-transform`)
- Endpoint: `POST https://agentbit.app/v1/util/transform` — 0.001 USDC per call
- Category: utility
- Hashing, HMAC, JWT decode, base64, UUID, JSON/CSV/XML conversion, URL parsing, semver comparison.
- Input fields:
  - `operation` (string, required)
  - `input` (string, optional)
  - `key` (string, optional)
  - `algorithm` (string, optional)
  - `a` (string, optional)
  - `b` (string, optional)
- Example request: `{"operation":"sha256","input":"agentbit"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/util/transform -H 'Content-Type: application/json' -d '{"operation":"sha256","input":"agentbit"}'`

### Feed Reader (`feed-read`)
- Endpoint: `POST https://agentbit.app/v1/web/feed` — 0.005 USDC per call
- Category: web
- Feed reading for monitoring agents. RSS and Atom remain the web's most reliable change-notification layer — blogs, news sites, release pages, status pages, podcasts and forums all publish them — but real-world feeds are a mess of formats, encodings and broken dates. This tool fetches a feed URL (SSRF-guarded), parses RSS 2.0, RSS 1.0/RDF and Atom including Dublin Core extensions, and returns uniform JSON items: whitespace-normalized title, resolved link, publication date converted to ISO-8601, summary stripped to plain text and capped at 1000 characters, author and categories. Given an HTML page instead of a feed, it reads the page's advertised alternate links and follows the first RSS/Atom one automatically — so agents can monitor 'that blog' without knowing its feed URL. Up to 50 items per call. Pair with structured-extract to find all of a site's feeds, and call on a schedule to turn any site into an event source.
- Input fields:
  - `url` (string, required) — Feed URL, or an HTML page URL to auto-discover the feed from
  - `limit` (integer, optional) — Max items to return (1-50, default 20)
- Example request: `{"url":"https://blog.cloudflare.com/rss/","limit":5}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/web/feed -H 'Content-Type: application/json' -d '{"url":"https://blog.cloudflare.com/rss/","limit":5}'`

### Structured Data Extract (`structured-extract`)
- Endpoint: `POST https://agentbit.app/v1/web/structured` — 0.01 USDC per call
- Category: web
- Structured-data extraction for agents that need facts, not prose. Most pages carry a machine-readable self-description that text scrapers throw away: schema.org JSON-LD (products with prices, articles with authors and dates, organizations, events, recipes, job postings), OpenGraph and Twitter Card metadata, the canonical URL, hreflang language alternates and advertised RSS/Atom feeds. This tool fetches the page (SSRF-guarded, size-capped) and returns all of it as clean JSON: up to 20 JSON-LD blocks decoded and their schema @types summarized, og:* and twitter:* maps, title, meta description, first H1, canonical, hreflang map and feed links. Use it to read product data without parsing HTML, to verify what a page claims to be before citing it, to find a site's feeds for monitoring (pairs with feed-read), or as the structured layer on top of web-extract's clean text.
- Input fields:
  - `url` (string, required) — Absolute http(s) URL of the page
- Example request: `{"url":"https://agentbit.app/blog"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/web/structured -H 'Content-Type: application/json' -d '{"url":"https://agentbit.app/blog"}'`

### Web Extract (`web-extract`)
- Endpoint: `POST https://agentbit.app/v1/web/extract` — 0.005 USDC per call
- Category: web
- Extract clean structured content (title, text, markdown, headings, links, metadata) from any public URL.
- Input fields:
  - `url` (string, required)
  - `output_format` (string, optional)
  - `render_fallback` (boolean, optional)
  - `include_links` (boolean, optional)
- Example request: `{"url":"https://example.com","include_links":true}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/web/extract -H 'Content-Type: application/json' -d '{"url":"https://example.com","include_links":true}'`

### Web Search (`web-search`)
- Endpoint: `POST https://agentbit.app/v1/web/search` — 0.015 USDC per call
- Category: web
- Live web search with title, URL, snippet and freshness data from multiple search providers with automatic failover.
- Input fields:
  - `query` (string, required)
  - `limit` (integer, optional)
  - `country` (string, optional)
  - `language` (string, optional)
  - `freshness_days` (integer, optional)
- Example request: `{"query":"x402 payment protocol for AI agents","limit":3}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/web/search -H 'Content-Type: application/json' -d '{"query":"x402 payment protocol for AI agents","limit":3}'`

### Website Agent Readiness (`website-agent-readiness`)
- Endpoint: `POST https://agentbit.app/v1/website/agent-readiness` — 0.05 USDC per call
- Category: web
- Audit any website for AI-agent readiness: robots.txt, llms.txt, sitemap, schema.org, AI crawler access, security headers. Returns 0-100 score.
- Input fields:
  - `url` (string, required)
- Example request: `{"url":"https://example.com"}`
- Try it (returns the 402 payment envelope): `curl -s -X POST https://agentbit.app/v1/website/agent-readiness -H 'Content-Type: application/json' -d '{"url":"https://example.com"}'`

## More
- Machine catalog: https://agentbit.app/catalog.json · OpenAPI 3.1: https://agentbit.app/openapi.json · MCP: https://agentbit.app/mcp
- Engineering notes on x402 integration pitfalls: https://agentbit.app/blog