> ## Documentation Index
> Fetch the complete documentation index at: https://docs.xentfi.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Live Demos
> Five fully working demo apps on the XentFi sandbox — agent wallets & policies, auto-settlement, deposit addresses, x402 facilitator payments, and hosted checkout, all click-through.
**Live demos**: every app below runs against the XentFi sandbox. No account needed — click into any one and try the flow yourself.
Each demo below is a small, fictional company built to show one XentFi capability end to end — the same UI a real merchant or developer would ship, wired to the same integration code shown in each demo's **Build it yourself** section. Together they cover the full surface: an autonomous agent with its own wallet and policy, automatic currency conversion on receipt, per-invoice deposit addresses, machine-to-machine payments over x402, and a hosted checkout page.
## What you can test
| Demo | Company | What it demonstrates | Build it yourself |
| ----------------------------------------------------------------- | ------------------------ | ----------------------------------------------------------------------------- | ----------------------------------------------- |
| [Agent Wallets & Policies](#aria-agent-wallets-spending-policies) | Aria (procurement agent) | An AI agent with its own wallet, spending policy, and Policy-checked payments | [Agent Tools](/essentials/agent) |
| [Auto-Settlement](#creatorpay-auto-settlement) | CreatorPay | Incoming volatile tips converted to USDC automatically on receipt | [Liquidity & Settlement](/essentials/liquidity) |
| [Deposit Addresses](#invoiceflow-deposit-addresses) | InvoiceFlow | A dedicated deposit address per invoice, reconciled by webhook | [Addresses](/essentials/addresses) |
| [x402 Facilitator](#modelmesh-x402-facilitator) | ModelMesh | Pay-per-call APIs billed to an AI agent over HTTP 402 | [x402 Payments](/essentials/x402) |
| [Hosted Checkout](#nova-threads-hosted-checkout) | Nova Threads | A storefront accepting stablecoins through a hosted checkout page | [Payment Links](/essentials/payment-links) |
***
## Aria — agent wallets & spending policies
Aria is a procurement agent with her own XentFi Agent Wallet and a spending policy her (fictional) finance team set once — a monthly budget, a per-transaction cap, and a vendor allowlist. She renews SaaS subscriptions autonomously, and every payment she attempts is checked against that policy server-side before a single token moves.
On the demo, pick a vendor and an amount and submit a purchase request — you'll watch Aria check the request against her live policy, sign with her agent wallet, and broadcast on-chain, or get denied with the specific reason (off-allowlist vendor, over the per-transaction cap, or over budget for the month).
**How it works:**
Register an Agent identity, then delegate it a chain-scoped wallet it can transact from — separate from the main treasury.
Set per-transaction and monthly USD limits plus a vendor/recipient allowlist. This is what runs on every purchase request submitted in the demo.
Aria's own scoped API key calls the payments endpoint directly — no backend has to broker each individual purchase.
Approved payments return a transaction hash immediately. Denied ones return a machine-readable reason the agent (or a human) can act on.
demos.xentfi.com/aria
Agent Tools guide, plus the Agent tab's [Quickstart](/agent/quickstart) and [Tools Reference](/agent/tools-reference)
***
## CreatorPay — auto-settlement
Fans tip creators in whatever they're holding — ETH, MATIC, ARB. CreatorPay's auto-settlement rule converts it to USDC the moment it arrives, so creators never carry volatile exposure they didn't ask for.
Pick a source asset and amount and simulate an incoming tip — you'll watch the rule trigger, find a route under the configured slippage tolerance, execute the swap, and credit USDC to the payout wallet.
**How it works:**
Define which incoming assets should trigger conversion, a single destination asset and wallet, and the route strategy to use.
Any tip in an accepted source asset landing on that wallet is picked up automatically — nothing to poll.
Based on the chosen strategy (fastest, cheapest, recommended, or no-slippage) the conversion executes within the configured slippage tolerance.
A `settlement.executed` webhook fires with the source amount, destination amount, and route used — that's what populates the log on the demo.
demos.xentfi.com/creatorpay
Liquidity & Settlement guide
***
## InvoiceFlow — deposit addresses
Every invoice on InvoiceFlow gets its own dedicated deposit address — no shared wallet, no memo codes to get wrong. Create an invoice and you're issued a fresh address scoped to that client and amount; simulate the client's payment and watch the invoice reconcile automatically.
**How it works:**
When an invoice is issued, request a fresh deposit address scoped to that invoice — never reuse one address across clients or invoices.
Display the address (and a QR code) alongside the amount and asset expected — the client sends funds directly, no intermediary custody step.
XentFi watches the address on-chain and fires a webhook the moment funds land — no polling a block explorer.
Match the webhook's `addressId` back to the invoice record and flip its status — exactly what the demo's "Simulate client payment" button does.
demos.xentfi.com/invoiceflow
Addresses guide
***
## ModelMesh — x402 facilitator
ModelMesh is a marketplace of pay-per-call model APIs — an image upscaler, a sentiment analyzer, a text-to-speech endpoint. No API keys, no monthly plans: an agent hits an endpoint, gets a `402`, pays in one round trip through the XentFi Agent Facilitator, and the request completes.
Click **Call** on any API and watch the full round trip play out live — the demo's `/verify` and `/settle` steps are real calls to the facilitator, not just an animation, and the flow ends with the actual API response.
**How it works:**
The resource server responds with HTTP 402 and a JSON body describing the price, asset, network, and payout address for the requested resource.
The calling agent's wallet signs a payment authorization and retries the request with an `X-PAYMENT` header — no separate checkout flow.
The resource server calls the facilitator's `/verify` endpoint to confirm the payment payload is well-formed and the agent can cover it, before doing any work.
Once verified, `/settle` executes the on-chain transfer, then the original request is fulfilled — both calls typically complete in well under a second.
demos.xentfi.com/modelmesh
x402 Payments guide, plus the Agent tab's [x402 Reference](/agent/x402-reference)
***
## Nova Threads — hosted checkout
Nova Threads is a streetwear storefront that accepts USDC, USDT, and ETH at checkout — no card fees, instant settlement, powered by XentFi Hosted Checkout. Add a product to cart and pay: you're redirected to a real hosted checkout session on testnet and land back on a confirmation page once it settles.
**How it works:**
Once the cart total is known, call the Payment Links API with the amount, currency, and a redirect URL back to the storefront.
Send the customer to the `checkoutUrl` the API returns — XentFi hosts the entire payment experience: wallet connect, network switch, confirmation.
After payment, the customer lands back on the `redirectUrl` with status details in the query string. Fulfill the order once the payment is verified server-side.
Don't rely on the redirect alone — listen for the `payment_link.paid` webhook event to confirm and fulfill reliably, even if the customer closes the tab early.
demos.xentfi.com/nova
Payment Links guide
***
## How the demos are built
Every demo is a small Next.js app against the XentFi sandbox, and each pairs a clickable UI with the exact integration code shown in its own **Build it yourself** panel — so what you click and what you'd ship are the same shape.
* The **x402 facilitator demo** makes real round trips to `/verify` and `/settle` as you click through it — those two steps are a live network call, not a timer.
* The **agent wallet, auto-settlement, and deposit address demos** simulate their multi-second flows (policy checks, route-finding, on-chain confirmation) client-side for a smooth walkthrough, while the code sample shown alongside each one is the real call you'd make against the API.
* The **checkout demo** redirects to a genuine XentFi Hosted Checkout session on testnet, so the payment page itself is fully real.
None of the demos require an account or a wallet with funds to click through — each one is seeded with example activity so the story is visible immediately, then lets you add to it live.
## Next steps
Give an AI agent its own wallet and policy, like Aria.
Bill AI agents per API call, like ModelMesh.
Add hosted checkout to a storefront, like Nova Threads.
Every endpoint behind all five demos.