DEV Community

Eli
Eli

Posted on

Test Stripe Checkout with an AI Agent Skill — No Stripe Account Needed

#agents #ai #testing #tutorial

Vercel Labs released a useful agent skill for anyone building payments: a Stripe Emulator skill.

The skill lets an AI agent test Stripe-like payment flows locally. It can create customers, products, prices, checkout sessions, payment intents, charges, payment methods, customer sessions, and webhooks without touching a real Stripe account.

That is exactly the kind of skill that should be easy to try.

This guide shows how to install Vercel Labs' Stripe Emulator skill in an OpenClaw or Hermes agent, run a first local Stripe test, and use ClawMama if you do not already have an agent runtime.

No real Stripe account is required.

No real Stripe secret key is required.

No real payment is processed.

Who this is for

This guide is for:

  • founders testing a checkout flow before setting up production payments;
  • developers who want a local Stripe-like API for app development;
  • AI agent builders who want a safe payment-testing workflow;
  • product teams that want agents to test checkout, customers, products, prices, and webhooks;
  • skill authors who want users to try a GitHub-hosted agent skill quickly.

The job is simple:

Let an AI agent test a Stripe checkout workflow locally before real payment credentials enter the system.

That is a good first workflow because the risk boundary is clear. The agent works against an emulator, not your production payment account.

The skill

Skill / repo:

vercel-labs/emulate
Enter fullscreen mode Exit fullscreen mode

Install command:

npx skills add vercel-labs/emulate --skill stripe
Enter fullscreen mode Exit fullscreen mode

For OpenClaw, use:

npx skills add vercel-labs/emulate --skill stripe --agent openclaw -y --copy
Enter fullscreen mode Exit fullscreen mode

What it gives your agent:

  • a local Stripe emulator;
  • a fake test key pattern such as sk_test_emulated;
  • realistic Stripe-like API responses;
  • local customers, products, prices, checkout sessions, payment intents, charges, and webhooks;
  • a hosted checkout UI for local testing.

The point is not to replace Stripe.

The point is to let an agent test payment logic before the workflow touches real money.

Step 1: Create a ready-to-use agent

If you already run OpenClaw or Hermes, use your existing agent.

If you do not, create one with ClawMama:

https://t.me/clawmamarun_bot
Enter fullscreen mode Exit fullscreen mode

ClawMama gives you a ready-to-use OpenClaw or Hermes agent. New users get $2 of AI credits, access to the latest ChatGPT model, and a simple Telegram control surface, so you can test a skill before maintaining your own infrastructure.

Think of it as creating a small agent workspace first, then giving that agent a specific skill.

In ClawMama language, you create a small lobster — a focused agent that can receive a task, install a skill, run a local workflow, and report back.

Step 2: Ask the agent to install the Stripe Emulator skill

Send this to your OpenClaw or Hermes agent:

I want to test Stripe checkout locally with Vercel Labs' Stripe Emulator skill.

Please install this skill:

npx skills add vercel-labs/emulate --skill stripe --agent openclaw -y --copy

After installing it, read the installed SKILL.md and summarize:
1. what the skill can do;
2. how to start the emulator;
3. what fake key to use;
4. which API endpoints are available;
5. any risks or setup notes.

Do not use any real Stripe API key.
Do not connect to a real Stripe account.
Enter fullscreen mode Exit fullscreen mode

A good agent should first inspect the skill instructions.

That matters. Skills run with agent permissions, so the agent should understand what it installed before it uses it.

Step 3: Start the local Stripe emulator

The verified start command is:

npx emulate --service stripe
Enter fullscreen mode Exit fullscreen mode

The emulator starts on:

http://localhost:4000
Enter fullscreen mode Exit fullscreen mode

A typical startup output looks like:

emulate v0.5.0

  stripe  http://localhost:4000

  Tokens
  test_token_admin -> admin

  Config: defaults (run emulate init to customize)
Enter fullscreen mode Exit fullscreen mode

The first run may install the emulate package from npm:

npm warn exec The following package was not found and will be installed: emulate@0.5.0
Enter fullscreen mode Exit fullscreen mode

That is expected for a local development tool.

Step 4: Create a test customer

Ask the agent to run a local request:

curl -X POST http://localhost:4000/v1/customers \
  -H "Authorization: Bearer sk_test_emulated" \
  -d "email=user@example.com" \
  -d "name=Jane Doe"
Enter fullscreen mode Exit fullscreen mode

Expected result:

{
  "id": "cus_Mpfm8dXJTRWa1o6e",
  "object": "customer",
  "email": "user@example.com",
  "name": "Jane Doe",
  "description": null,
  "metadata": {},
  "livemode": false
}
Enter fullscreen mode Exit fullscreen mode

The exact customer ID will be different.

The important field is:

"livemode": false
Enter fullscreen mode Exit fullscreen mode

That tells you this is not a real Stripe live transaction.

Step 5: List customers

Now ask the agent to list customers:

curl http://localhost:4000/v1/customers \
  -H "Authorization: Bearer sk_test_emulated"
Enter fullscreen mode Exit fullscreen mode

The agent should return a Stripe-like list response.

This gives you a simple first loop:

create customer → list customers → inspect response
Enter fullscreen mode Exit fullscreen mode

That is enough to prove the emulator is running.

Step 6: Create a product

Next, test product creation:

curl -X POST http://localhost:4000/v1/products \
  -H "Authorization: Bearer sk_test_emulated" \
  -d "name=Widget" \
  -d "description=A useful widget"
Enter fullscreen mode Exit fullscreen mode

Expected result:

{
  "id": "prod_6ftApyNURynBJZGu",
  "object": "product",
  "name": "Widget",
  "description": "A useful widget",
  "active": true,
  "metadata": {},
  "livemode": false
}
Enter fullscreen mode Exit fullscreen mode

Again, the exact ID will differ.

The useful part is that your agent can now test payment-related app behavior against a local API.

Step 7: Use it inside an app

If your app uses the Stripe Node SDK, there is one important detail.

The Stripe SDK does not automatically read an emulator base URL from an environment variable. You need to point the client at the local emulator when constructing it:

import Stripe from 'stripe'

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, {
  apiVersion: '2024-12-18.acacia',
  host: 'localhost',
  port: 4000,
  protocol: 'http',
})
Enter fullscreen mode Exit fullscreen mode

Use a fake key:

STRIPE_SECRET_KEY=sk_test_emulated
Enter fullscreen mode Exit fullscreen mode

This key is not from your real Stripe dashboard. It is a local test value for the emulator.

Step 8: Ask the agent to test a checkout flow

Once the emulator is running, give your agent a task like this:

Using the local Stripe emulator at http://localhost:4000, help me test a basic checkout flow.

Use the fake key:
sk_test_emulated

Please:
1. create a customer;
2. create a product named "Starter Plan";
3. create a price for $19/month if the emulator supports recurring prices;
4. create a checkout session if supported;
5. show the local checkout URL or API response;
6. summarize what worked and what failed.

Do not use real Stripe credentials.
Do not call api.stripe.com.
Do not process a real payment.
Enter fullscreen mode Exit fullscreen mode

This is the workflow that makes the skill useful.

The agent is not just reading documentation. It is using the skill to test a real development path.

Step 9: Add webhook testing

The Stripe Emulator skill also supports webhooks.

A good next task is:

Help me test a local Stripe webhook handler with the emulator.

First, explain the webhook events this emulator can send.
Then create a minimal local webhook endpoint example.
Then show how to configure the emulator to send events to it.

Keep everything local.
Use fake keys only.
Enter fullscreen mode Exit fullscreen mode

This is especially useful for app teams.

Webhook testing is one of the places where payment development becomes slow. A local emulator gives your agent a safe target to exercise the flow.

What the agent should produce

A useful result from the agent should include:

  • install confirmation;
  • emulator startup command;
  • local endpoint URL;
  • fake key used;
  • customer creation result;
  • product creation result;
  • checkout session or payment intent result;
  • webhook notes;
  • app integration changes;
  • what remains untested;
  • clear statement that no real payment was processed.

That final statement matters.

Payment workflows need a clean boundary between local testing and production money movement.

Why this works well with ClawMama

This kind of skill is a good fit for ClawMama because the user does not need to start by maintaining an agent server.

The path is simpler:

create a ClawMama agent → install the Stripe Emulator skill → run a local test → inspect output
Enter fullscreen mode Exit fullscreen mode

For a new user, that means:

  • no VPS setup first;
  • no custom agent runtime first;
  • $2 of AI credits to test the workflow;
  • access to the latest ChatGPT model;
  • OpenClaw or Hermes as the agent runtime;
  • Telegram as the control surface.

For a skill author, this also matters.

A GitHub repo is powerful, but many users still need a first successful run. A ready-to-use agent gives the skill a shorter path from announcement to adoption.

Safety notes

A few rules keep this clean:

  • Review installed SKILL.md files before using them.
  • Do not give the agent real Stripe secret keys for this test.
  • Do not point the app at api.stripe.com while testing the emulator workflow.
  • Remember that npx skills add installs from GitHub.
  • Remember that npx emulate runs an npm package.
  • Keep this as a local development workflow, not a production payment setup.
  • If port 4000 is busy, start the emulator on another port: 
npx emulate --service stripe --port 5000
Enter fullscreen mode Exit fullscreen mode

Also note that emulator state is local. If you restart it, assume you may need seed data unless you configure persistence or seed files.

Final takeaway

Vercel Labs' Stripe Emulator skill is a strong example of what agent skills should do.

It gives an agent a narrow, useful capability: test payment flows locally without real payment credentials.

With ClawMama, a user can create a ready-to-use OpenClaw or Hermes agent, install the skill from GitHub, run a first test, and see a real Stripe-like response in minutes.

That is the right shape for an agent skill:

specific capability → easy install → safe first run → useful output
Enter fullscreen mode Exit fullscreen mode

Start with the smallest test:

npx skills add vercel-labs/emulate --skill stripe --agent openclaw -y --copy
npx emulate --service stripe
curl http://localhost:4000/v1/customers -H "Authorization: Bearer sk_test_emulated"
Enter fullscreen mode Exit fullscreen mode

If that works, your agent has a safe local payment lab.

Top comments (0)