Paybond with Shopify agentic commerce

In one line: Shopify moves the order through checkout; Paybond decides whether the payment should capture and writes the receipt. Shopify helps merchants sell through agents — product discovery, cart building, checkout orchestration, and order lifecycle through UCP and MCP (Catalog, Cart, Checkout, Order) alongside the merchant's existing storefront and payments stack.

Paybond is the trust layer underneath agent spend — a signed spend agreement (intent), release or refund based on signed completion evidence (proof-gated settlement), operator disputes, and cryptographically signed portable receipts.

This guide is for Shopify partner, platform, and merchant teams — including the Technology Partner track where a partner enables UCP/MCP agentic checkout, dev-store validation, and governed capture timing on top of Shopify orders.

How Paybond complements Shopify

Combined value: Shopify answers whether an agent can discover products, build a cart, and place an authorized order. Paybond answers whether policy was satisfied before capture, refund, or human escalation — with a portable signed receipt.

What to integrate (Kit first)

Two layers in one purchase

Many Shopify checkouts can stop after the order is created and paid. Paybond matters when capture should not be automatic:

• procurement agents with acceptance criteria
• high-trust B2B agent spend with audit requirements
• flows where disputes need a shared evidence record, not chat logs
• marketplaces where an operator governs release or escalation

Shopify surfaces (2026)

Technology Partner angle

For Shopify Technology Partners validating agentic commerce on Plus dev stores:

1. Platform tenant configures settlement in Paybond Configuration → Settlement — linked shop domain, allowed rails (shopify_authorized_order, shopify_payments_app), server-owned OAuth credentials. Clients never pass shop domains in create payloads.
2. Agents run behind Kit middleware with tenant-derived API keys — scope comes from credentials, not client-supplied tenant ids.
3. Shopify executes UCP/MCP checkout and produces the canonical order; Paybond gates capture/void against predicates.
4. Operators review disputes, unbound webhook events, and audit exports from a single Harbor and Ledger record.

Paybond does not replace Shopify checkout UI or merchant payment relationships. It adds intent-scoped escrow and evidence so partners can offer governed agent commerce without building a custom settlement state machine.

Reference flows (both products)

Two common orderings — pick based on whether checkout or spend policy comes first.

A. Checkout-first (UCP/MCP)

B. Guard-first (Kit middleware around checkout tool)

Shopify answers: Can this agent discover products, build a cart, and place an authorized order?

Paybond answers: Did the agent satisfy policy before we capture, void, or escalate to a human?

Manual capture (conditional settlement)

When release depends on Paybond predicates — not automatic capture at checkout — merchants should enable manual payment capture in Shopify Admin under Settings → Payments. Checkout then authorizes without capturing; Paybond drives capture (or void) on drive_terminal_settlement for shopify_authorized_order — the same mental model as ACS manual capture on Stripe.

Checkout-first merchants: create the Paybond intent when conditional escrow starts, stamp checkout metadata with the same binding contract, and treat Shopify order webhooks as funding — not completion evidence.

Tenant-admin checklist: Configure Shopify settlement.

What Paybond adds on Shopify rails

Paybond integrates Shopify for intent-scoped settlement, not workspace billing:

Harbor snapshots tenant settlement config server-side — clients never pass shop domains or offline access tokens in create payloads.

Integration surface for partners:

For webhook paths, capture timing, and stuck-intent recovery, see Settlement with existing payment providers.

Kit at the agent boundary

Application teams wire Paybond Kit middleware around Shopify checkout tools. Guard-first flows use the commerce.checkout operation with cost_and_completion evidence — the same primary operation as Protect Shopify payments from agents:

paybond login
paybond agent sandbox smoke \
  --operation commerce.checkout \
  --requested-spend-cents 4500 \
  --evidence-preset cost_and_completion \
  --result-body '{"status":"completed","cost_cents":4500,"order_id":"gid://shopify/Order/123","shop":"paybond-agent-commerce-dev.myshopify.com"}' \
  --format table

paybond login
paybond agent sandbox smoke \
  --operation commerce.checkout \
  --requested-spend-cents 4500 \
  --evidence-preset cost_and_completion \
  --result-body '{"status":"completed","cost_cents":4500,"order_id":"gid://shopify/Order/123","shop":"paybond-agent-commerce-dev.myshopify.com"}' \
  --format table

Kit helpers for UCP/MCP checkout with binding metadata:

• createCheckoutWithBinding({ intentId, tenantId, ... }) — stamps paybond_intent_id / tenant_id in note_attributes for webhook preflight
• Shopify CLI workflow: paybond shopify doctor, paybond shopify checkout smoke

Offline rehearsal without API credentials: paybond dev loop --offline and paybond dev trace (local dashboard at http://127.0.0.1:9477).

Production pattern:

1. Shopify (UCP/MCP or storefront) completes buyer checkout when the flow is catalog with payment execution. Enable manual capture when Paybond will drive capture on release.
2. Paybond intent funds on the tenant's allowed Shopify rail when the agent needs a bounded spend boundary before side effects.
3. Evidence attaches tool results (not Shopify funding webhooks); Paybond evaluates predicates.
4. Release or refund drives Shopify capture/void or payment session resolution.
5. Agent Receipt Standard (ARS) emits portable signed proof for operators and partners.

See Protect Shopify payments from agents for checkout tool guarding and How agent settlement works for the five-step proof-gated lifecycle.

Binding contract (tenant isolation)

To tie agent checkout to tenant-owned settlement configuration, every agent-initiated checkout must attach binding metadata in Shopify:

• paybond_intent_id
• tenant_id

For UCP/MCP, place it in note_attributes (or cart attributes that propagate to the order). Gateway webhook preflight then enforces:

• shop domain (X-Shopify-Shop-Domain) is linked to the authenticated tenant
• payload contains binding metadata
• binding metadata matches a known Paybond intent for that tenant

If binding is missing or mismatched, events must route to manual review and must not fund intents automatically.

UCP agent profile

Host and register the Paybond platform profile for Shopify partner onboarding:

GET https://paybond.ai/.well-known/ucp/profile.json

Kit Shopify helpers default meta.profile_url to this URL when building checkout payloads with createCheckoutWithBinding. Register the profile URL in the Shopify Developer Dashboard before calling Checkout MCP at https://{shop}/api/ucp/mcp.

Sandbox and onboarding path

paybond shopify doctor
paybond shopify dev                    # prints two-terminal workflow
paybond shopify checkout smoke --shop paybond-agent-commerce-dev.myshopify.com

paybond shopify doctor
paybond shopify dev                    # prints two-terminal workflow
paybond shopify checkout smoke --shop paybond-agent-commerce-dev.myshopify.com

Harness: examples/shopify-dev-loop. Docs: Shopify CLI workflow. For agents that also route Stripe or Zinc checkouts under one tool, see Multi-provider commerce checkout.

Tenant-admin setup: Configure Shopify settlement. Developer task guide: Protect Shopify payments from agents.

When to use which

Security and tenant boundaries

• Tenant scope is derived from authenticated credentials — never from client-supplied tenant ids.
• Shop domains and offline access tokens are server-owned in settlement config; agents must not hold them.
• Funding webhooks are separate from completion evidence (tool results after capability_token).
• Any event missing binding metadata is treated as unbound and excluded from automated funding.
• Unbound webhooks route to manual review — operators follow Paybond dispute workflows with a canonical ledger record.

See Disputes and evidence evaluation and Secure agentic banking infrastructure.

Co-sell and support

Summary

Shopify executes agentic cart and checkout and produces the canonical order record.

Paybond makes agent spend authorized, verified, and auditable — escrow, evidence, release rules, disputes, and signed portable receipts on top of Shopify orders.

Together they cover the full agentic commerce stack: cart and checkout on Shopify, conditional settlement and standing on Paybond.

Where to go next