Papilio lets you set up, run, and debug your entire payments backend in plain English. No developer. No Stripe dashboard. No waiting on someone else to fix it.
Your stack has an auth layer, a data layer, and an API layer. In 2026 it needs a payments layer — one your agent can talk to, your founder can query, and you don't have to maintain. That's Papilio.
Describe your business once. Then ask it anything — who owes you money, which payments failed, what changed last month. In plain English. Instantly.
Describe your entities in natural language or drop in JSON. Papilio generates a strictly typed schema — string, number, boolean, date, enum, reference — and provisions your backend. No migrations. No ORM. No schema design sessions. Every field has a description that powers the natural language query layer. Strict types enforced at provision time. Foreign key validation. Enum constraints.
{
"entities": {
"customer": {
"fields": {
"name": { "type": "string", "required": true },
"email": { "type": "string", "required": true },
"monthly_fee": { "type": "number", "required": true },
"status": { "type": "enum",
"values": ["active", "paused", "cancelled"] }
}
},
"invoice": {
"fields": {
"customer_id": { "type": "ref", "entity": "customer" },
"amount": { "type": "number" },
"status": { "type": "enum",
"values": ["pending", "paid", "failed"] }
}
}
},
"flows": {
"monthly_billing": {
"trigger": "schedule:monthly:1:00:00",
"steps": [
{ "action": "collect_payment" },
{ "action": "create_entity", "type": "invoice" },
{ "action": "export", "integration": "xero" }
]
}
}
}Define your payment flows once — collect, retry, notify, export, branch. Papilio runs them on schedule, handles failures with the logic you set, and gives you a complete execution log when something goes wrong. You write the rules. You don't babysit the runs.
Set the rules once. When something needs your attention, you handle it in plain English — no developer, no waiting, no guessing.
Tell Papilio who your customers are, what they pay, and when. It sets up your entire payments backend — invoices, subscriptions, reminders, exports — without you writing a line of code or hiring a developer.
Describe your entities in plain English or drop in JSON. Papilio generates a strictly typed schema and provisions your backend. No migrations to write. No ORM to configure. No schema design session that runs three hours and ends in a Confluence doc nobody reads. When your founder wants to add a field, they describe it. It's done.
{
"entities": {
"customer": {
"description": "A paying subscriber",
"payment_role": "initiator",
"fields": {
"name": {
"type": "string",
"required": true,
"description": "Full legal name"
},
"email": {
"type": "string",
"required": true
},
"monthly_fee": {
"type": "number",
"required": true,
"description": "Subscription fee in NZD"
},
"status": {
"type": "enum",
"values": ["active", "paused", "cancelled"]
},
"plan_id": {
"type": "ref",
"entity": "plan",
"description": "The plan this customer is on"
}
}
}
}
}Your payment flows run exactly as configured — every time. If something fails, Papilio retries automatically. If it needs your attention, it tells you. No surprises. No silent failures.
Flows are directed step graphs. Each step is a typed action — collect money, create a record, call a webhook, export to Xero, branch on a condition. Every step puts its output into shared context for the next step.
Every step puts its output into shared context. collect_payment.amount is available to every subsequent step.
Debit a bank mandate or charge a card. GoCardless, Stripe, or Akahu.
Send money to any bank account or Stripe connected account. Fees split automatically.
Insert a new entity record mid-flow. Fields populated from step context.
Modify entity fields as a flow step. Update balances, statuses, timestamps.
Evaluate an expression and route to different steps. If balance > 50, pay out.
POST a signed payload to any URL. Notify your backend on any step completion.
Send data to Xero, MYOB, or any integration. Triggered as a flow step.
Pause a flow for a defined duration before the next step executes.
Same eight endpoints regardless of your schema. Your data model changes — the API contract doesn't. No custom endpoints to build, no internal documentation to maintain, no breaking changes when the founder decides to add a field. The endpoints are stable. Everything else is configuration.
// TypeScript SDK const papilio = new Papilio({ tenantId: 'pap_tenant_001', apiKey: process.env.PAPILIO_API_KEY, }) const customers = await papilio .get('customer', { status: 'active' }) await papilio.flows .execute('monthly_billing', tenantId)
Set up, run, and debug your payments backend yourself — in plain English.
No servers, no migrations, no DevOps. Papilio handles everything behind the scenes.
Ask who owes you money, what failed, or what changed — and get an answer instantly.
No SQL. No reports. No waiting. Just ask.
The same endpoint accepts plain English from your founder, structured filters from your code, and raw aggregation pipelines when you need them. Same auth, same response shape. One interface that works for everyone on the team.
| Customer | Amount | State | Date |
|---|---|---|---|
| cst_sarah_c | $450.00 | failed | Mar 10 |
| cst_james_w | $380.00 | failed | Mar 12 |
| cst_mike_t | $520.00 | failed | Mar 13 |
| cst_emma_d | $290.00 | failed | Mar 14 |
papilio.query({
entity: 'payment',
filter: {
state: 'failed',
fulfilled: true
},
sort: { created_at: -1 },
limit: 50
})papilio.query.raw([
{ $match: {
state: 'failed',
fulfilled: true
}},
{ $group: {
_id: '$customer_id',
total: { $sum: '$amount' }
}},
{ $sort: { total: -1 }}
])Papilio ships with a native MCP server. The moment you connect it to Cursor or Claude, two things happen: you get a natural language interface to your entire payments layer, and your founder gets one too. They stop asking you why payments failed. They just ask Papilio.
npm install -g @papilio/mcp// .cursor/mcp.json { "mcpServers": { "papilio": { "command": "papilio-mcp", "env": { "PAPILIO_API_KEY": "pk_test_xxx" } } } }
Papilio is infrastructure you control. The MCP server, the natural language query, the agent tooling — all of it is optional. You decide how much AI touches your stack, if any. The flows you define are deterministic logic. AI is just one of the ways you can interact with what you've built.
Call Papilio from your backend like any other service. Your flows run on schedule or on demand. No AI anywhere near your customers or your money. Papilio is just a very good payments layer.
Connect MCP to Cursor or Claude. You get a natural language interface for debugging, querying, and inspecting schemas — in your editor, in your sandbox. Production flows stay deterministic. AI never touches a customer.
Give your founder read access via MCP. They can query payment data, check statuses, understand what's happening — without pinging you. Write operations still require explicit confirmation. You set the boundaries.
Agent queries, triggers flows, handles retries, notifies customers — all within the rules you've defined in your flow config. Every action is logged. You review, adjust the rules, stay in control at the configuration level.
From solo founders to engineering teams.
Use the Papilio dashboard as your entire interface. Configure entities, build flows, manage records, query data. No code required.
Connect Papilio's MCP server to Cursor, Kiro, or Claude. Query live data, trigger flows, debug failures — all in natural language from your editor.
Build your product on top of Papilio. Use the dashboard for configuration, the SDK for integration. Your users never know Papilio exists.
Papilio keeps an immutable record of everything — not because you asked, but because that's how it's built. When someone asks what happened to a payment, you'll know.
Every payment state transition, flow execution, entity change, and config update is timestamped and append-only. Not because you asked for an audit trail — because that's how Papilio works. Query the full history through the same API. SOC 2 Type I in progress.
Built for the moment someone asks you to prove it.
That's not a feature you configure. It's how Papilio works.
Switch to the developer view and send them the link.
They'll understand immediately — and they can get access on your behalf.
A base subscription gives you the platform. Flow executions scale with your actual usage — so your costs match your business activity.
Try the platform. Ship your first flow.
For teams running real payment operations.
For growing businesses processing serious volume.
High volume, custom rails, SLA.
Custom tenants, executions, and records. Dedicated infrastructure available.
Each time Papilio runs a payment flow from trigger to completion. A monthly billing run across 50 customers = 50 executions.
Schema generation, entity queries, NL queries, MCP tool calls, dashboard usage, and sandbox runs are all free.
The average Papilio customer replaces 2–4 weeks of developer time at setup.
USD prices · NZD equivalent shown at ~1.65 exchange rate · updated quarterly.
No waitlist. No spam. We'll reach out within 24 hours.
No waitlist. No spam. We'll reach out within 24 hours.
No waitlist. We'll reach out within 24 hours.
No waitlist. No spam. We'll reach out within 24 hours.