Give an AI agent a task that needs an API it has never used and it gets surprisingly far. It finds the API, reads the docs, writes the request, and then hits the same wall every time: the API wants a key, a key belongs to a person, and the person has to stop what they're doing and sign up. Half the time the session ends right there, with "please create an account and paste your key here."
As of today, storefronts on APIDirectory can take that wall down. A seller switches on trial keys, and an agent that arrives without a key can get a real one with a single request: no signup, no email, no card. It does the task. When it's done, or when the trial runs out, it hands its human a link. The human confirms an email, and the same key keeps working on the seller's free plan. Whatever the agent built doesn't change.
We switched it on first for our own geocoding API, geocode.net. Everything below is a real session against production, run this evening with nothing but curl.
An agent with no key
The first thing an agent tries is the call itself. The gateway's answer used to be a polite dead end. Now it says where to go:
$ curl -s 'https://api.geocode.net/v1/geocode?q=1600+Pennsylvania+Ave+NW+Washington+DC'
{"error": "key_required",
"detail": "pass X-API-Key — get one at https://dash.geocode.net/, or POST
https://dash.geocode.net/trial for a trial key with no signup",
"trial": "https://dash.geocode.net/trial"}
One POST, no body:
$ curl -s -X POST https://dash.geocode.net/trial
HTTP/2 201
{"status": "trial_key_issued",
"key": "apigw_00ab…01eb",
"base_url": "https://api.geocode.net/",
"auth_header": "X-API-Key",
"allowance": 100, "unit": "request", "expires": "2026-10-19",
"claim_url": "https://dash.geocode.net/claim/29.<token>",
"claim": "Give claim_url to your user. They confirm an email and this same key moves
to the Free plan (10,000 requests/mo), so nothing you built has to change.",
"mcp_endpoint": "https://mcp.geocode.net/", ...}
That's a real gateway key, metered and rate-limited like any other, on a hidden plan: 100 requests that never refill, for seven days. The agent uses it straight away:
$ curl -s -D - 'https://api.geocode.net/v1/geocode?q=1600+Pennsylvania+Ave+NW+Washington+DC' \
-H "X-API-Key: $GEOCODE_API_KEY"
HTTP/2 200
x-gw-plan: trial
x-gw-limit: 100
x-gw-remaining: 99
x-gw-trial-ends: 2026-10-19
x-gw-claim: https://dash.geocode.net/claim/29.<token>
{"formatted": "1600 Pennsylvania Ave NW, Washington, DC 20500",
"location": {"lat": 38.897675, "lng": -77.036545},
"accuracy_type": "rooftop", "source": "nad", ...}
Every response says what's left and where the key becomes someone's. Agents read headers, so the claim link is always in reach, not only at the end.
Running out
We spent the rest of the allowance with one batch of 99 addresses and asked for one more:
HTTP/2 429
{"error": "quota_exceeded",
"detail": "this trial key has used the 100 requests it came with. Your user can keep
it working: they open the claim link and confirm an email",
"limit": 100, "used": 100, "plan": "trial",
"claim": "https://dash.geocode.net/claim/29.<token>"}
This is the moment the whole thing is built for. By now the agent's code works; it has geocoded real addresses and knows the response shape. What it asks its human for isn't "sign up for a geocoding service." It's "click this to keep the thing I just built running." The claim page says what the agent used and where the key goes. The human types an email, clicks the link we send, and lands on their account with the key already on it, now on the free plan's 10,000 requests a month. Seven days later the key would have stopped with a 403 trial_expired that carries the same link, and a lapsed trial can still be claimed.
Finding the trial in the first place
An agent can come in through several doors, and each one now mentions the trial:
- The API itself, as above: the 401 names the trial endpoint.
- The storefront's agent quickstart (dash.geocode.net/agents.md) says "No key yet?" and gives the one-line
curl. - APIDirectory's MCP server:
get_apireportsmarketplace.trial, andsubscribe_apicalled without an email returns a trial key instead of an error. - The seller's own MCP server lists a
start_trialtool to a client that connected without a key.
What stops this from being free geocoding for everyone
Handing out keys to anyone who asks is the obvious objection, and it was the first thing we built around:
- It's explicit. A key is never created just because a request arrived without one. Scanners hit API endpoints all day and nobody reads their responses. You have to POST.
- It's bounded per address and per day. At most three trial keys per address per API per day, and 100 per API per day in total. The second number is the one that holds, because cloud agents share IP addresses and an address can be faked. So the worst a seller can lose on a given day is 100 trials' worth of calls, and they set the allowance.
- A big request can't overrun it. This one we found while building it. Geocode.net's batch endpoint takes up to 10,000 addresses and reports the real cost after doing the work, so a 100-request trial key could have run one 10,000-row batch. The gateway now tells the origin how much the key has left (
X-Gw-Remaining), and geocode.net refuses anything bigger before it starts:
HTTP/2 429 (a batch of 150 on a key with 99 left)
x-gw-cost: 0
{"error": "allowance_exceeded",
"message": "this request costs 150 units and the key has 99 left; send fewer items,
or move to a larger plan"}
That fix wasn't only for trials. The same overshoot was open on every capped plan, free ones included, and it's closed now.
- It never bills anyone. Nobody agreed to anything when the key was minted, so a trial key can only ever be free. Money starts only after a person claims the key and picks a plan.
If you sell an API
Trial keys are a switch in your storefront's console, under Plans. You set the allowance (in your own units, for the whole trial) and how many days it lasts, and you can see how many trials were issued and how many were claimed. Trial calls reach your origin like any other call. If your origin bills per item through X-Gw-Units, honour X-Gw-Remaining before you switch it on. It's off by default, because anonymous traffic is your cost and your decision.
The bet is simple. More and more of the first calls to an API come from agents, and an agent that can't get a key leaves. One that can will often finish the job before anyone has decided whether to sign up. When the person shows up, the decision is already made.
What's next
An MCP client fixes its key in config, so today an agent that starts a trial through start_trial has to reconnect with the key, or switch to plain HTTP. The lazier version would mint the trial on the first keyless tool call and tie it to the MCP session, so the agent never handles a key at all. After that comes OAuth for connectors, which turns the claim step into a "Connect" button. We'll report back on how many trials get claimed once there's something to count.