FAQ

Straight answers for developers evaluating any of these before integrating. The free-tier numbers reflect what the products actually do today; paid-plan figures, where stated, are what those plans will cost when they open.

Receipt Extraction (AU GST-aware)

What does it cost? The free tier is self-serve today: 20 documents/month, no card required. Paid plans are opening soon — pay-as-you-go at $0.02/document (no minimum), and Pro at $19/month for 1,500 documents (~$0.013/doc effective) with priority support. Want a paid plan now? Register your interest and we’ll set you up first.

How do I get an API key? Free-tier keys are self-serve — get one here, or call the API directly: POST /v1/signup with { "email": "you@example.com" } returns the key directly in the response. It’s shown once and can’t be recovered if lost, so store it immediately (re-sign up for a new one otherwise). Paid plans aren’t self-serve yet; when they open, paid keys provision the same way via a one-time claim link.

What does it do, and how accurate is it? It turns a receipt or invoice into structured JSON — vendor, line items, tax, totals — with validation built in. It’s been validated 4 of 4 on a hand-built four-document test set — one document each for net-priced, GST-inclusive-only, checksum-invalid-ABN, and unreadable-document cases; broader production accuracy will be tracked as live traffic grows.

How does it handle Australian GST and ABN? It validates the vendor’s 11-digit modulus-89 ABN checksum and cross-checks GST across line items and totals. Each line item carries a tax_code, a confidence, and a one-line rationale naming the rule applied — including denying input tax credits on entertainment expenses by default, and flagging the incidental-to-travel exception when it applies.

Is the output schema stable? Output is explicit JSON with a schema_version field (currently 1.0). It’s versioned so a model change doesn’t silently shift the shape under your integration.

What input formats does it take? A receipt or invoice image or PDF, submitted as a base64 string with its MIME type. Both are handled by the same extraction pipeline.

Can I use plain HTTP instead of MCP? Yes — it works identically as an MCP server (the extract_receipt tool) or a plain HTTPS API from any HTTP client. Authenticate with an Authorization: Bearer YOUR_API_KEY header (a raw key value without the Bearer prefix also works); tool discovery doesn’t require a key, only the extraction call does.

How is my document data handled? Data handling follows the ACJ Labs privacy policy — retention, storage, and deletion specifics live there rather than in the API docs.

Is there an npm client for the receipt extraction API? Yes — @acjlabs/receipt-extraction-client is a typed TypeScript client that calls extract_receipt directly, no MCP wiring required. Pass your raw API key as apiKey — the client adds the Bearer prefix itself, so don’t include it yourself.

Does extraction ever return corrupted or invalid data? No — every result is checked against the Receipt schema before it’s returned. A result that fails that check (for example, non-finite numbers from a garbled read) doesn’t crash the service: at the raw API/MCP level it comes back as isError: true at HTTP 200, so structurally malformed data never reaches you silently. The npm client checks isError for you and throws a JS Error in that case instead of returning it, so wrap extractReceipt calls in a try/catch.

Are there rate limits or usage quotas? Yes. Free-tier keys get 10 requests/minute; Pro keys will get 120/minute once paid plans open. Your monthly document quota is a hard cap: on the free tier, once you hit 20 documents the API returns HTTP 402 rather than continuing to bill; Pro’s 1,500-document quota will work the same way once it opens. A rate-limited call inside your quota returns HTTP 429 with a Retry-After header. Both cases return a JSON body naming the reason (quota_exceeded or rate_limited), not a bare status code.

Catalog Attribute Normalizer

What does it cost? The free tier is self-serve today: 500 products/month, no card required. Paid plans are opening soon — pay-as-you-go at $0.01/product (no minimum), and Pro at $29/month for 5,000 products (~$0.0058/product effective). Want a paid plan now? Register your interest and we’ll set you up first.

How do I get an API key? Self-serve — get one here, or call the API directly: POST /v1/signup with your email returns the key directly, good for 500 products/month, no card. It’s shown once — store it immediately. Paid plans aren’t self-serve yet; when they open, paid keys provision the same way via a one-time claim link.

What does it do, and how accurate is it? You supply product batches (titles, descriptions, attributes); it returns canonicalized attributes plus category mappings for the taxonomies you request. Against a live model API it scored 22 of 24 checks (91.7%) exact path + leaf-ID matches on a 12-product evaluation set — each product checked against both Google and Shopify. A later live check through the deployed service itself scored 11 of 12 on the Google side of that same 12-product evaluation set — one check per product.

How does coverage differ across Google, Shopify, and Amazon? Google and Shopify classification is retrieval-grounded — real candidate paths are pulled from the current taxonomy files and every returned leaf ID is verified against them. Amazon has no comprehensive public taxonomy file to retrieve against, so it stays best-effort (recall from memory) rather than retrieval-grounded.

Retrieval-grounded or zero-shot? Retrieval-grounded: candidates come from the real taxonomy files and are offered to the model as suggestions, not recalled from memory. This is what prevents the confident-but-wrong fabricated leaf IDs a zero-shot prompt produces.

What does a null leaf ID mean? It’s an honest “check this” signal — the model couldn’t confirm a leaf ID against the real taxonomy, so it returns null rather than fabricate one. Treat null as a prompt to verify, never as a guarantee.

How are attributes and output structured? Attributes are keyed by a controlled vocabulary (size, color, material, gender, sleeve_length); unrecognized keys are dropped rather than passed through under a model-chosen name. Each value carries a provenance field — canonicalized when it came from your own input — so you can tell deterministic normalization from model inference.

How do I call it? Via the normalize_catalog MCP tool, a plain HTTPS API, or the @acjlabs/catalog-attribute-normalizer-client npm package. Same auth as above: Authorization: Bearer YOUR_API_KEY (tool discovery needs no key).

What does the normalize_catalog request look like? You send an array of products (up to 200 per call), each with title, description, and raw_attributes — your own key/value pairs, e.g. {"colour": "Navy"} — plus target_taxonomies: one or more of google, shopify, amazon. The tool returns one result per product, same order, so you can zip results back to your request by index.

If one product in a batch fails, does it break the whole request? No — a per-item classification failure (say, a classifier-provider hiccup on one product) is isolated to that product: it comes back as { error, source_title } in its position in the results array, same length and order, with every other product’s real result still returned. One exception, deliberate: if the classifier returns a structurally invalid result without throwing (a code/adapter bug, not an operational failure), the whole call fails with isError: true instead — that’s treated as a possible systemic defect, not silently downgraded to a one-off per-item error. The npm client throws a JS Error for that whole-call failure (not for per-item errors), so wrap normalizeCatalog calls in a try/catch.

---

x402 Bazaar Listing Monitor

What does it cost? The free tier is self-serve today: watch up to 200 resource URLs, polled every six hours, no card required. Paid tiers — tighter polling plus escalation and rank-drop detection — are not open yet and pricing is still being set. Want one? Register your interest and we’ll set it up with you.

Do I need an API key? No. The MCP tool check_listing_health is unauthenticated — point your client at https://x402-listing-monitor.acjlabs.com/mcp and call it. Scheduled watching needs no key either; you register a payTo address and your resource URLs and the poll runs from there.

What does it actually check? It diffs the resources you registered against Coinbase CDP’s public Bazaar discovery catalog, scoped to your payTo address, and records each one as listed or missing. When that status changes between polls it records a drop or a recovery with a timestamp — so you have a history to cite rather than a point-in-time answer.

Why would I need this? CDP’s discovery API has a recurring, publicly reported class of bug where a resource silently stops appearing despite confirmed settlements. Sellers currently catch it by re-running the discovery query by hand on their own schedule, or by noticing a revenue dip days later. This is that same check, kept up.

How quickly will I know? The free tier polls every six hours, so a drop is recorded at the next poll after it happens — not instantly. Paid tiers tighten that interval. The service makes no real-time guarantee.

Will it email me when something drops? Not yet, and the page says so. Changes are detected and stored with a durable timestamped history; outbound delivery (email or webhook) is the next thing being wired. A webhook URL supplied at registration is kept and used once it ships.

Can I check something without registering? Yes — that is exactly what the check_listing_health MCP tool is for. It runs the same scoped diff on demand for any payTo and resource list, registered or not.

Are there rate limits? Yes, per-IP limits on the write endpoints (/register and /poll) and on MCP tool calls. Normal use does not come near them.

Is the source available? The documentation repository is public. The service implementation is not open source — it is a hosted service.

Ready to try one? See Products for the quick-start, or the official MCP registry and npm.

GST handling reflects publicly documented Australian tax law and is provided as software output, not tax advice.