Order-First Payment Infrastructure

One object. Cart to refund.

Stop stitching together carts, charges, and webhooks. Flint starts with the Order: line items, tax, discounts, payments, refunds, and a full audit trail. One API. Always in sync.

No credit cardFree sandbox forever5 min to first order
Without Flint
You build all of this. You maintain all of this.
With Flint
OrderPAID
Click any issue above to see how Flint solves it
Ex-Square
Engineering team
Order-first
Architecture
Stripe
Powered payments
Fewer
Webhooks needed

The problem

Payment-first APIs push complexity onto you.

Stripe processes payments. That's it. Everything else (line items, inventory, tax, discounts, order state, fulfillment) is your problem. You end up building an order management system just to accept a credit card.

You become the database

Stripe gives you a PaymentIntent. Where are the line items? Your database. Tax? Your database. Discounts? Your database. Now reconcile all three.

~200 lines of glue code

State lives everywhere

Cart state in Redis, order state in Postgres, payment state in Stripe, fulfillment state in a third system. Good luck keeping them in sync.

5+ webhook handlers

Refunds are guesswork

A customer wants to return one item. Stripe sees a $94.50 charge. Which items? What tax? You figure it out.

Per-charge, manual

AI agents are blind

AI sees a PaymentIntent: { amount: 9450, currency: "usd" }. No items, no quantities, no context. It cannot reason about your business.

Zero semantic data

Cart to checkout

Same use case. Two different worlds.

A coffee shop checkout: 2 items, a coupon, tax, and a redirect. Here's what you write with Stripe. Then with Flint.

Stripe + your code
6 files
1. Look up your cartget-cart.ts
1const cart = await db.cart.findUnique({
2 where: { id: cartId },
3 include: { items: true, customer: true },
4})
5
6if (!cart) throw new Error("Cart not found")
96 lines across 6 files+ tax provider + DB schema + webhook endpoint
FlintOrder-first
2 files
1. Create an ordercreate-order.ts
1const order = await flint.orders.create({
2 line_items: [
3 {
4 name: "Oat Milk Latte",
5 quantity: 2,
6 unit_price_money: {
7 amount: 550,
8 currency: "USD",
9 },
10 },
11 {
12 name: "Blueberry Muffin",
13 quantity: 1,
14 unit_price_money: {
15 amount: 450,
16 currency: "USD",
17 },
18 },
19 ],
20 discounts: [
21 { coupon: { coupon_code: "WELCOME10" } },
22 ],
23 customer_id: "cus_01HZ4X9...",
24})
33 lines across 2 filesTax, coupons, order sync. All handled.
Tax calculation
You build it
Automatic
Coupon validation
You build it
Built-in
Order storage
Your database
On the Order
Payment sync
Webhook + reconcile
Automatic

AI-Native

The only payment API that AI agents actually understand.

Traditional payment APIs return raw amounts. AI can't reason about what was bought, shipped, or refunded. Flint's schema includes machine-readable hints so agents execute safely without custom logic.

AgentMethodHints: CreateRefund
proto schema
operation_type:CREATE
idempotency:IDEMPOTENT_WITH_KEY
side_effect_level:FINANCIAL
requires_human_confirmation:true
terminal_states:["SUCCEEDED","FAILED"]
poll_method:"GetOperation"
cost_class:BILLED
AI Agent Execution
Live
"Refund the coffee beans from Sarah's last order"
Reading schema hints for CreateRefund...
  side_effect: FINANCIAL
  requires_human_confirmation: true

Found order ord_01HZ4X9, Sarah Chen, Jan 15
Line item: Organic Coffee Beans (2x $19.99)
Refundable: $39.98

This moves money. Confirm refund of $39.98?
"Yes, process it"
Refund ref_01HZ5B2 created → PROCESSING
Polling GetOperation (1.5s interval)...
Status: SUCCEEDED

Customer notified. Order balance updated.
Side-effect awarenessIdempotency keysTerminal state pollingScoped permissionsHuman confirmation gatesRetry safety hints
Start simple. Grow without rewrites.

We scale with your complexity so you don't have to.

Start with a single payment intent and a Stripe source. When you outgrow just taking payments, everything else is already there. orders, inventory, checkout, refunds. No migration. Same API.

Just payments
Accept a payment with a Stripe source. One API call. No orders, no line items, no complexity.
const pi = await flint.paymentIntents.create({
amount_money: { amount: 2500, currency: "USD" },
source_id: "pm_1Qs2...x4B", // Stripe token
auto_confirm: true,
})
// pi.status → "SUCCEEDED"
// That's it. No order needed.

Subscriptions

Multi-item subscriptions, not multi-object headaches.

Stripe subscriptions are built around a single Price. Bundling multiple items means creating Products, Prices, and Subscription Items separately. Flint lets you define everything in one plan.

Stripe
7 API calls
1// 1. Create a product for each item
2const gym = await stripe.products.create({
3 name: "Gym Access",
4})
5const training = await stripe.products.create({
6 name: "Personal Training (4x/mo)",
7})
8const nutrition = await stripe.products.create({
9 name: "Nutrition Plan",
10})
11
12// 2. Create a price for each product
13const gymPrice = await stripe.prices.create({
14 product: gym.id,
15 unit_amount: 4900, currency: "usd",
16 recurring: { interval: "month" },
17})
18const trainingPrice = await stripe.prices.create({
19 product: training.id,
20 unit_amount: 12000, currency: "usd",
21 recurring: { interval: "month" },
22})
23const nutritionPrice = await stripe.prices.create({
24 product: nutrition.id,
25 unit_amount: 2900, currency: "usd",
26 recurring: { interval: "month" },
27})
28
29// 3. Create the subscription with each item
30const sub = await stripe.subscriptions.create({
31 customer: "cus_xxx",
32 items: [
33 { price: gymPrice.id },
34 { price: trainingPrice.id },
35 { price: nutritionPrice.id },
36 ],
37})
38
39// Want a 7-day trial? Add trial_period_days.
40// Setup fee? Add a one-time price to
41// add_invoice_items on the subscription.
42// Contract term? Build it yourself.
42 lines across 7 API calls+ separate objects for each item
FlintOrder-first
2 API calls
1const plan = await flint.subscriptionPlans.create({
2 name: "Premium Membership",
3 billing_interval: "MONTHLY",
4 billing_interval_count: 1,
5 currency: "USD",
6 line_items: [
7 { name: "Gym Access",
8 price_money: { amount: 4900, currency: "USD" },
9 quantity: 1 },
10 { name: "Personal Training (4x/mo)",
11 price_money: { amount: 12000, currency: "USD" },
12 quantity: 1 },
13 { name: "Nutrition Plan",
14 price_money: { amount: 2900, currency: "USD" },
15 quantity: 1 },
16 ],
17 trial_period_days: 7,
18 setup_fee_money: { amount: 2500, currency: "USD" },
19 contract_term_months: 12,
20})
21
22const sub = await flint.subscriptions.create({
23 plan_id: plan.plan_id,
24 customer_id: "cus_01HZ4X...",
25})
26
27// Trial, setup fee, contract term, multi-item
28// billing — all in one plan object.
28 lines across 2 API callsTrials, setup fees, contracts built-in
Multi-item plans
Multiple objects
One plan
Setup fees
Separate invoice item
First-class field
Pause & resume
Update a flag
Dedicated RPCs
Contract terms
Build it yourself
Native support

Order Lifecycle

One object from cart to close.

No glue code. Every transition is an explicit API call with a full activity trail.

Define items, customer, discounts. Tax is computed automatically.

due_money: $38.28

Developer Experience

An API you'll actually enjoy using.

Typed SDKs for TypeScript, Python, and Go. Full autocomplete. Idempotency keys on every write. Consistent patterns across every endpoint.

create-order.ts
const order = await flint.orders.create({
line_items: [
{
name: "Organic Coffee Beans",
sku: "COFFEE-001",
quantity: 2,
unit_price_money: { amount: 1999, currency: "USD" },
},
],
discounts: [
{
manual: {
name: "Welcome discount",
amount_money: { amount: 500, currency: "USD" },
scope: "ORDER",
},
},
],
customer_id: "cus_01HZ4X9...",
idempotency_key: crypto.randomUUID(),
})
// order.net_amounts.due_money → { amount: 3828, currency: "USD" }
// order.activities → [CREATED, DISCOUNT_APPLIED, TAX_UPDATED]

Pricing

One price. Everything included.

Stripe charges extra for tax, fraud screening, invoicing, and billing. We don't.

How much could you save?

Based on 12,000 txns/yr at $50 avg

$600K/yr
yearly revenue
$60K$12M
S
Stripe + add-ons
Processing (2.9% + 30¢)$21,000
Total / year$27,240
F
Flint Growth ($49/mo)
Processing (2.9% + 30¢)$21,000
Platform ($49/mo)$588
Tax automation$0
Fraud screening$0
Invoicing + receipts$0
Total / year$21,588

Save $5,652/yr on Flint Growth

$49/mo pays for itself at $600K/yr volume

FeatureStripeFlint
Tax automation0.5% per txnFree
Invoicing0.4% per invoiceFree
Fraud screening$0.07 per txnFree
Recurring billing0.5% per txnFree
Receipt emailsRequires BillingFree
Order managementBuild it yourselfFree
Inventory trackingBuild it yourselfFree
Coupons & discountsBasic onlyFree

Build

For side projects and testing

Free
3.6% + 35¢ per transaction
  • No monthly fee
  • All API features
  • TypeScript, Python, Go SDKs
  • Sandbox environment
  • Webhook retries & logs
  • Community support
Most Popular

Growth

For growing businesses

$49/mo
2.9% + 30¢ per transaction
  • Lower transaction fees
  • Everything in Build
  • Custom checkout branding
  • Priority support
  • Tax automation
  • Advanced reporting
  • AI assistant

Enterprise

For high-volume platforms

Custom
volume pricing
  • Everything in Growth
  • Custom fee structure
  • Dedicated account manager
  • SLA guarantee
  • Custom integrations
  • Compliance assistance
No setup feesCancel anytimeFree migration support

Card data never touches your servers. Powered by Stripe's PCI Level 1 infrastructure.

Frequently asked questions

5 minute setup

Start building the futureof commerce.

One API call. One order object. Tax, discounts, payments, refunds. All handled. Get your API keys and ship your first order in minutes.

const order = await flint.orders.create({ ... })
No credit card requiredFree sandbox foreverProduction ready in minutes

Designed by ex-Square engineers who built commerce infrastructure serving millions of sellers.