Engineering
Can AI agents order through a reseller API?
Can AI agents order through a reseller API? Yes, if the API publishes an OpenAPI document, idempotency keys, a sandbox key and signed webhooks for events.
The short answer
Can AI agents order through a reseller API today? Yes, provided the API gives the agent four things: a machine-readable description of itself, a way to avoid double-buying on a retry, a way to test before spending real money, and a way to be told about events instead of having to guess. An OpenAPI 3.1 document, an Idempotency-Key header, a sandbox key and signed webhooks cover all four. A separate convention, llms.txt, helps an agent find its way around a site's documentation, but it is not a search-ranking signal and nothing here claims otherwise.
Can AI agents order through a reseller API today? Yes, but only as well as the API lets them. An agent that calls a reseller API is not doing anything a human developer's code could not also do: it sends an HTTP request, reads the response, and decides what to do next. What changes is who is making the decisions about retries, error handling and what to try next, usually without a person reading every line first. That shifts the weight onto four things the API itself has to get right: a description of itself the agent can read without guessing, a way to avoid paying twice for one order, a way to rehearse the whole thing before any money moves, and a way to find out what happened without polling in a loop. Get those four right and an agent can order a domain, rent a phone number or buy mailbox seats the same way a careful developer would. Get them wrong, and the agent either stalls, double-buys, or quietly fails in a way nobody reviews until the invoice arrives.
Can AI agents order through a reseller API? Four things it has to get right
Four things, each solving a different failure mode:
- A machine-readable description of the API. An OpenAPI 3.1 or 3.2 document lets an agent see every route, every field and every error code without reading prose documentation first, the same way a code generator does.
- A way to avoid double-buying on retry. An
Idempotency-Keyheader lets the server recognise a retried request as the same request, so a dropped connection does not turn into two domains or two phone numbers. - A way to test without spending real money. A sandbox key runs the agent's plan against a copy of the account that cannot touch real funds or a real upstream provider, so mistakes are cheap to find.
- A way to be told about events instead of polling. A signed webhook tells the agent's code when an order finishes, a renewal fails or a number receives a message, without the agent having to ask over and over.
The second of these, retry safety, is covered in full in idempotency keys and signed webhooks: the two things a reseller API must get right, including how Stripe and Adyen implement it and what the underlying IETF draft actually specifies. This article does not repeat that; it is about the surrounding pieces an agent specifically needs, starting with how it reads the API in the first place.
What is OpenAPI, and why does an agent need it?
OpenAPI is a specification for describing an HTTP API in a single machine-readable document, so that "both humans and computers" can discover what a service does "without access to source code, documentation, or through network traffic inspection" (OpenAPI Specification v3.1.0, Introduction). An agent reading that document knows every route, every required field and every error it can get back, which is a better starting point than reading prose and guessing at a request shape.
The current release is OpenAPI 3.2.1, published 10 September 2026; 3.1 is still maintained separately at 3.1.2 (OpenAPI Specification, latest). The detail that matters most for agent tooling is in the Schema Object, the part of the document that describes the shape of a request or response body: in both 3.1.0 and the latest 3.2.1 text it is, by the specification's own words, "a superset of the JSON Schema Specification Draft 2020-12" (OAS 3.1.0 - Schema Object; OAS latest - Schema Object). A header parameter such as Idempotency-Key is described the same way, as a Parameter Object with in: header (OAS 3.1.0 - Parameter Object).
That one detail, the JSON Schema dialect, is also what connects OpenAPI to the Model Context Protocol below.
What is the Model Context Protocol, and does ResellerHQ have an MCP server?
The Model Context Protocol, or MCP, is a separate, open protocol for connecting an LLM application to external tools and data. In its own words, MCP "enables seamless integration between LLM applications and external data sources and tools," using JSON-RPC 2.0 messages between a host (the LLM application), a client (a connector inside it) and a server (something that exposes tools and data) (MCP specification, revision 2026-07-28). A server built on MCP lists its tools in a tools/list response and runs one when asked with tools/call; each tool has an inputSchema, which is "JSON Schema defining expected parameters" and "Defaults to 2020-12 if no $schema field is present" (MCP - Tools). The protocol itself is intentionally narrow: as of the 2026-07-28 revision it describes "Stateless, self-contained requests" with no connection-scoped session, a change from earlier revisions that kept one (MCP - Transports, Backward Compatibility).
ResellerHQ does not run an MCP server. It publishes a REST API described by an OpenAPI 3.1 document, which is a different, older and more general way of describing the same kind of capability: both are a machine-readable list of operations, a schema for each one's inputs and outputs, and a way to call them over HTTP. The two are related rather than competing, because they default to the same schema dialect: an MCP tool's inputSchema and an OpenAPI 3.1/3.2 Schema Object both fall back to JSON Schema Draft 2020-12 when no other dialect is named. In practice that means the same set of field definitions could, in principle, describe both a REST parameter and an MCP tool argument, which is one reason a team that already has an OpenAPI document is in a reasonable position to build an MCP server from it later, should it choose to. Nothing on this page should be read as saying ResellerHQ has already done that.
What is llms.txt, and does it help a site rank in Google?
llms.txt is a proposed, optional Markdown file placed at a site's root (or at a path within it) that gives an agent "a curated overview" of the site to read, as distinct from a sitemap, which "list[s] all pages for search engines" (llms.txt, v2). The format is an H1 with the project's name, a blockquote summary, and then optional Markdown sections, each a list of links an agent can follow for more detail. Version 2, published August 2026, added link relations so a page can point to its own Markdown twin and to the llms.txt that covers it, and dropped some of the original proposal's mechanical rules for how an agent should read the file, leaving it to "view or search the llms.txt to find what they need, then follow the relevant links" (llms.txt - Changes). The proposal's own stated expectation is narrower than "SEO": "Our expectation was that llms.txt would mainly be useful for inference rather than training, and that is how it has been used" (llms.txt, v2).
Chrome's Lighthouse tool audits for the file as part of its agentic-browsing checks, flagging only a server error on the request, and treating a missing file as "Not Applicable" rather than a failure, because the file is optional; its stated reason for the audit is that "without this file, agents may spend more time crawling the site to understand its high-level structure and primary content" (Chrome for Developers - Lighthouse llms.txt audit). That is a statement about crawl efficiency for agents, not about search ranking.
On ranking specifically, Google is direct. Its generative-AI optimisation guide, last updated 10 July 2026, states: "You don't need to create new machine readable files, AI text files, markup, or Markdown to appear in Google Search (including its generative AI capabilities), as Google Search itself doesn't use them," and that creating one "will neither harm nor help your site's visibility or rankings in Google Search, as Google Search ignores them" (Google Search Central: Optimizing for generative AI search). Its separate page on AI features in Search makes the same point about requirements generally: "There are no additional requirements to appear in AI Overviews or AI Mode, nor other special optimizations necessary" beyond being indexed and eligible for a normal snippet (Google Search Central: AI features and your website). Any article, including this one, that claims an SEO ranking benefit from publishing llms.txt is going beyond what either specification or Google itself says.
| What it is for | Who reads it | Affects Google ranking? | |
|---|---|---|---|
robots.txt | Says what automated access is acceptable | Crawlers deciding whether to fetch a page | Indirectly, via what gets crawled |
sitemap.xml | Lists every page, for discovery | Search engine crawlers | Helps discovery, not ranking directly |
llms.txt | A curated summary and link list for an agent's own inference | AI agents and assistants reading a site live | No, by Google's own statement above |
Sources: llms.txt, Google Search Central: Optimizing for generative AI search.
What does ResellerHQ publish for an agent today?
Checked against the code, as of October 2026:
| Resource | Address | What it is |
|---|---|---|
| Site summary and docs index, as Markdown | /llms.txt | Generated from the same facts as the landing page, so a person and an agent read the same claims (apps/web/src/lib/site.ts, apps/web/src/app/llms.txt/route.ts) |
| Every docs page in one file | /llms-full.txt | Every docs page rendered to Markdown and joined (apps/web/src/app/llms-full.txt/route.ts) |
| Any docs page as Markdown | its URL with .mdx appended | Each page is also served as plain Markdown at its own address |
| The API's OpenAPI 3.1 document | /api/openapi.json | Generated by the API itself with openapi: '3.1.0' (apps/api/src/app.ts) and served to the dashboard's own API reference from a checked-in snapshot (apps/web/src/lib/openapi.ts) |
| A prompt to hand to a coding agent | shown on the agents guide | Points the agent at /llms.txt and the OpenAPI document, then asks it to create a customer, check the price, order with an Idempotency-Key, and add a webhook handler (apps/web/src/lib/site.ts) |
| A test key an agent cannot use to spend real money | a key prefixed rhq_test_ | Authenticates only against a separate sandbox account with its own wallet, whose domain and licence orders are filled by in-memory test providers rather than a real registry or licence distributor, and whose phone numbers are filled by an in-memory provider that "issues no real numbers" (apps/api/src/environment.ts, apps/api/src/deps.ts, packages/providers/src/types.ts) |
This is a distinct, narrower list than the agents guide itself, which is written for a developer pasting a prompt into an agent rather than for explaining why each piece exists; read that page for the prompt text and the exact addresses, and this one for what each piece is for and where the claims above come from in the code.
A checklist before you hand an agent a live key
- Start it on a sandbox key. A key prefixed
rhq_test_can only ever authenticate against the sandbox account, which has its own wallet and is filled by test providers, so nothing the agent does there can touch real money. Review the plan it produces before moving to a live key. - Make it send an
Idempotency-Keyon every call that spends money. An agent retries automatically on a timeout or a 5xx, and without a key a retry is a second order. See idempotency keys and signed webhooks for exactly how that header should behave and what to check in any provider's documentation. - Have it branch on the error code, not the error message. Error text can be reworded without changing behaviour; the machine-readable
errorfield in a response is the stable part. - Give it a webhook handler, not a polling loop. An agent that polls for order status burns calls and still has to decide when to stop; a signed webhook tells it the moment something changes.
- Review a sandbox run the way you would review a pull request. A sandbox pass shows that the agent's code reacts correctly to a completed order, a failed one, a retry and a bad signature; it does not prove a live upstream provider behaves identically, a distinction covered in how to test a reseller API integration in a sandbox.
None of this is specific to ResellerHQ. Any reseller API an agent is pointed at should be checked against the same four requirements from the first section above before an agent is given a key that can spend real money.
Questions
- Yes, through the same REST API a human developer would use, provided it is described in a format the agent can read and gives the agent a way to retry safely. Nothing about the order itself is different when an agent places it; what matters is whether the API publishes an OpenAPI document, accepts an Idempotency-Key on purchases, offers a sandbox to test in first, and sends signed webhooks for anything asynchronous.
- No. Google's own guidance says plainly that it does not need, read or rank on files like this: "You don't need to create new machine readable files, AI text files, markup, or Markdown to appear in Google Search (including its generative AI capabilities), as Google Search itself doesn't use them," and that such a file "will neither harm nor help your site's visibility or rankings in Google Search, as Google Search ignores them."
- The Model Context Protocol (MCP) is an open protocol that lets an LLM application connect to external tools and data over a standard JSON-RPC interface, so a coding agent can discover and call a server's tools without custom glue code for each one. ResellerHQ does not run an MCP server; it publishes a REST API described by an OpenAPI 3.1 document, which is a different way of describing the same kind of capability and one an agent, or a developer, can read directly.
- The agent sends the same unique key on the original request and on any retry of it, and a server that implements the pattern stores the outcome of the first request and returns that same outcome on a repeat instead of running the purchase again. This matters more for an agent than for a person, because an agent retries automatically and will not notice a duplicate charge the way a person checking their inbox would.
- A sandbox key authenticates against a separate copy of an account that is funded with test money and filled by a test provider rather than a real registry, carrier or licence distributor, so nothing it does can spend real money or create a real order. Giving an agent a sandbox key first lets you review what it actually did, including any mistakes, before it ever touches a live key.
- Both default to the same schema dialect, JSON Schema Draft 2020-12: an OpenAPI 3.1 or 3.2 Schema Object is, by the specification's own words, "a superset of JSON Schema Specification Draft 2020-12," and an MCP tool's inputSchema "Defaults to 2020-12 if no $schema field is present." That shared dialect is why the same validation rules can describe a REST parameter and a tool argument.
Sources
- llms.txt: the /llms.txt file, v2 llmstxt.org
- llms.txt: Changes (v2) llmstxt.org
- OpenAPI Specification, latest (v3.2.1) spec.openapis.org
- OpenAPI Specification v3.1.0 spec.openapis.org
- Model Context Protocol specification, revision 2026-07-28 modelcontextprotocol.io
- Model Context Protocol: Tools modelcontextprotocol.io
- Google Search Central: AI features and your website developers.google.com
- Google Search Central: Optimizing for generative AI search developers.google.com
- Chrome for Developers: Lighthouse llms.txt audit developer.chrome.com