Live on the Trust Fabric network

Payment intelligence and orchestration for the agentic economy.

Card payments through Stripe, charged on your own Stripe account, with every event on a cryptographically auditable ledger. Integrate in minutes — no demo required, no sales call to ship.

  • Hash-chained ledger
  • PCI DSS scope-minimized
  • Signed webhooks
  • 99.95% core-API uptime target
create-session.sh
# One random key per checkout you create. Keep it with the order and
# send it again only to retry this same create.
KEY="$(uuidgen)"
curl https://api.trustfabric.ai/v1/checkout/sessions \
  -H "Authorization: Bearer $PAID_SECRET_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $KEY" \
  -d '{
    "mode": "payment",
    "currency": "USD",
    "payment_method_types": ["card"],
    "line_items": [{
      "ad_hoc": {"amount": 4999, "currency": "USD", "description": "Pro plan"},
      "quantity": 1
    }],
    "success_url": "https://example.com/thanks",
    "cancel_url": "https://example.com/cancel"
  }'
One request to a hosted checkout. No card data touches your servers.

Why builders trust PAID

≤ 200ms
p95 read-API latency (SLO)
99.95%
Core API uptime target
1
Payment method offered today: cards, through Stripe
300+
Documented API endpoints (openapi.json)

Everything a real payments stack needs.

No demoware. Every feature is wired to the same production ledger that runs the Trust Fabric.

Cards through Stripe

Card payments through Stripe, charged on the merchant's own Stripe account, are the only payment method PAID offers today. Other rails are not offered.

Cryptographic ledger

Every financial event is hash-chained and append-only. Reconciliation reads the chain against the processor's statement, hourly.

Self-serve onboarding

API keys in minutes. No sales call required to integrate or test in live mode.

Trust Fabric attestation

Tenant admission gate, attestation receipts, and provider health surfaced to every customer.

PCI scope removal

Hosted checkout and Stripe Elements integration keep card data out of your servers.

Production observability

Provider health, fraud signals, settlement timing, and disputes in one dashboard.

From signup to first charge in under five minutes.

The full integration path. No live demo, no waiting.

01

Create an account

Sign up, verify your business, and grab your live API keys — no demo required.

02

Create a checkout session

One API call returns the session and its hosted checkout URL. Send the buyer there yourself, or let the embed button do it.

03

Get paid

Receive a signed webhook on success. Reconciliation is automatic. Funds settle on your schedule.

Drop-in embed

One line of HTML on any page or app. Your server creates the checkout with its secret key; the button sends the buyer to PAID's hosted page for it, and PAID notifies you over webhook on completion.

Embed reference
index.html
<!-- {{ checkout.id }}: the id your server got back from
     POST /v1/checkout/sessions (created with your secret key). -->
<button data-paid-checkout
  data-session-id="{{ checkout.id }}">
  Pay $49.99
</button>

<script async src="https://paid.trustfabric.ai/v1/embed.js"></script>

Signed webhooks

Every event is signed with your webhook secret using HMAC-SHA256. Verify in one call and react. Retries are automatic with exponential backoff and a dead-letter queue.

Webhook reference
webhook.ts
// POST https://your-app.com/api/webhooks/paid
// PAID signs every event with your endpoint's whsec_ secret:
//   Webhook-Signature: t=<unix_ts>,v1=<hmac_sha256_hex over "<ts>.<raw body>">
// Companion headers (Standard Webhooks-style names): Webhook-ID for
// idempotency, Webhook-Timestamp for replay rejection.

import crypto from "node:crypto";

function verifyPaidSignature(payload: string, header: string, secret: string): boolean {
  const [tPart, sPart] = header.split(",");
  const t = (tPart ?? "").replace(/^t=/, "");
  const s = (sPart ?? "").replace(/^v1=/, "");
  const expected = crypto
    .createHmac("sha256", secret)
    .update(t + "." + payload)
    .digest("hex");
  return (
    s.length === expected.length &&
    crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(s))
  );
}

export async function POST(req: Request) {
  const payload = await req.text();
  const sig = req.headers.get("Webhook-Signature") ?? "";
  if (!verifyPaidSignature(payload, sig, process.env.PAID_WEBHOOK_SECRET!)) {
    return new Response("bad signature", { status: 400 });
  }

  const event = JSON.parse(payload);
  switch (event.type) {
    case "payment_intent.captured":
      await grantEntitlement(event.data.customer_id);
      break;
    case "payment_intent.failed":
      await notifyCustomer(event.data.customer_id, event.data.last_error);
      break;
  }

  return new Response("ok");
}

Honest, usage-based pricing.

One flat rate — 1% per transaction, plus 10¢ only on payments over $20 — on every plan. No setup fees. No monthly minimums. You only pay for successful charges. Your payment provider's own fees (e.g. Stripe's 2.9% + 30¢ per card) are separate and additional; we never hide them inside our rate. See full pricing →

Starter

1% + 10¢
per transaction · 10¢ only over $20 · $0/mo
  • Hosted checkout
  • Flat 1% on card payments through Stripe
  • Self-serve API keys
  • Webhook delivery + signing
  • Standard dispute handling
Start free

Growth

$499/mo
same flat 1% + 10¢ over $20
  • Everything in Starter
  • Trust Fabric admission gate
  • Multi-provider routing
  • Dedicated reconciliation
  • SAML SSO + audit log
  • Priority engineering support
Talk to sales

Ready to ship?

Create an account and have your first checkout session live before your coffee is cold.