Integrated before lunch.

The promise, stated plainly

Connect your coding agent to our MCP server — or hand it the quickstart URL and let it use the plain REST API. In one working session it can create a sandbox, set up products and prices, run a checkout end to end, and then fast-forward a simulated year to prove the integration survives renewals, upgrades, failed cards and disputes.

One session. No signup form before the first API call, no sales call before the docs, no waiting for anyone at lernaura to notice you exist.

The rest of this post is that paragraph, step by step.

A sandbox in one call

The first thing your agent does is create a sandbox: one API call, no signup, no credentials required to make it. Back comes an isolated account with real API keys — a full copy of the platform where everything works and nothing is real money.

That ordering is deliberate. The traditional flow — register, verify your email, fill in a company profile, then find the API keys — is built for a person with a browser. An agent starting from nothing but a base URL needs the opposite: credentials first, paperwork later, and only when there's something worth keeping.

There is nothing to install and nothing to configure. The sandbox is the product, minus the consequences.

From zero to a checkout

With keys in hand, the agent builds the actual integration: products, prices, and a checkout — one-time purchases, subscriptions in every variant, usage billing, paid by card or by classic invoice, whichever your customers expect.

Over MCP, the agent doesn't guess at any of this. It discovers the operations, their schemas and the golden path the same way it discovers anything else it's connected to — which is what makes the difference between an agent that writes plausible-looking billing code and one that writes correct calls against the real surface.

By the time it runs the first end-to-end checkout in the sandbox, you have the thing most billing projects don't produce until week three: a working sale, observed, not assumed.

Prove it, hard

A checkout that works once is a demo. The reason billing integrations ship with untested paths isn't laziness — it's that the interesting failures live months in the future. The renewal that lands after the card expired. The upgrade halfway through a period. The dispute on an invoice from last quarter.

The sandbox has a virtual clock and simulated payments precisely for this. Your agent can fast-forward a year of your billing in minutes: renewals fire, cards fail on schedule, dunning runs, a dispute arrives — and the integration either survives all of it or fails now, in the sandbox, where failing is free.

This is the step we care most about, because it changes what "done" means. Not "the happy path worked once," but "a year of edge cases ran, and here's the log." Your agent doesn't just build the integration — it hands you the evidence.

One human step

When the integration is proven, a human does the one thing an agent shouldn't: claim the account and verify the business, in a single web session. Know-your-customer checks are the one gate we keep deliberately human — it's a merchant of record you're plugging into, and on every sale lernaura is legally the seller.

That's the whole ceremony. Everything the agent built in the sandbox carries over; production access is rolling out to design partners first, and the sandbox is open to everyone today.

One human step, at the end, with everything already working — rather than a week of human steps at the beginning, before you know whether it will.

Prefer to build by hand?

Everything above works without an agent. The MCP server and the REST API are the same surface: same operations, same docs, same sandbox, same virtual clock. If you'd rather read the quickstart yourself and write the calls in an afternoon, the afternoon is all it takes.

The point was never that agents are mandatory. It's that an integration simple enough for an agent to complete unsupervised is also the simplest possible integration for you.