Félix Pago

WhatsApp distribution & conversational UX

Félix's core insight is distribution, not crypto: its users already live in WhatsApp, so there's no app to download, account to create, or website to visit. The interface is a conversation with an AI assistant.

• Built on the WhatsApp Business / Cloud API — messages in and out are webhooks + send calls.
• Conversational AI handles Spanish, regional slang, and voice notes — not a rigid form, which matters for a first-time-digital demographic.
• Zero-install, zero-website funnel removes the biggest drop-off in remittance onboarding.
• Single point of distribution risk: the business depends on Meta's API access, policy, and pricing.

Stablecoin settlement + last-mile payout

Under the chat, Félix runs the classic 'stablecoin sandwich': USD → USDC → local currency. The sender funds in USD (Stripe), Félix settles the cross-border leg in USDC via Bridge/Circle, and a local partner pays out — making the rail invisible.

• Funding: US card/bank via Stripe Payments + Connect (~90% card auth per Stripe).
• Settlement: USDC over stablecoin rails (Bridge — a Stripe company — and Circle) replaces correspondent banking/SWIFT.
• Last-mile: dLocal (current) and earlier Bitso/Stellar off-ramp USDC and disburse local currency, typically <2 min, ~99% success.
• Net result: minutes-not-days delivery at lower cost than the 6–13% legacy remittance fees Félix set out to undercut.

Compliance & remittance licensing

Money transmission is the hard, regulated core. Moving consumer dollars across borders requires licensing/sponsorship in each jurisdiction, KYC/AML on senders, and cross-border reporting — orchestrated across multiple parties.

• KYC/AML gates the first transfer; sanctions screening on each send.
• A 'complex multi-party setup' is used to satisfy money-transmitter rules (per Stripe) — the real cost/moat center.
• Payout partners (e.g. dLocal) operate under local regulation per market and handle in-country compliance + reporting.
• Corridor expansion (Colombia, Ecuador, Peru, Nicaragua) each adds a new regulatory surface.

Risk & competitive position

• Platform risk: total dependence on WhatsApp/Meta for distribution and UX.
• Concentration: leans on dLocal for last-mile and USDC/Bridge for the rail.
• Fraud/chargebacks on card-funded inbound legs; FX volatility in LatAm corridors.
• Crowded corridor (Remitly, Wise, MoneyGram + crypto-native rivals) — moat is distribution + the engaged WhatsApp user base, into which Félix plans to cross-sell savings and credit.

Architecture

Félix is a consumer remittance app with NO public developer API — what's interesting is how the stack is composed. The 'frontend' is WhatsApp itself: messages arrive via the WhatsApp Business / Cloud API as webhooks. An AI/agent layer (LLM-driven, multilingual, voice-capable) parses intent, runs KYC/onboarding, and quotes the transfer. Once confirmed, three back-end legs fire: (1) FUND — collect USD from the sender via Stripe (Payments + Connect for multi-party flows); (2) SETTLE — convert to USDC and move value cross-border via Bridge/Circle liquidity; (3) PAYOUT — call a last-mile partner (dLocal, formerly Bitso) to off-ramp USDC into local currency and disburse to the recipient's bank/cash point. State is tracked per transfer and pushed back to the user as WhatsApp messages. The hard parts are compliance orchestration (a multi-party MTL setup) and the conversational UX — not the rail itself.

Integration shape

To build something like this you compose three vendor APIs behind a chat agent: WhatsApp Cloud API (receive/send messages via webhooks), a payments API for funding (Stripe), and a stablecoin-payout API for settlement + last-mile (Bridge for USD↔USDC; dLocal/Bitso for local payout). The AI layer sits in the middle as an orchestrator: it maps free-form messages to a structured transfer object, then drives a state machine across the funding → settlement → payout legs, idempotently, with KYC gating before the first send.

API surface

WhatsApp Cloud API — webhook

[verify] Inbound message events (text / voice / interactive replies) POSTed to your server; verify Meta's signature, then route to the agent.

WhatsApp Cloud API — /messages

[verify] Send replies, quotes, and confirmations back to the user (text + interactive buttons / templates).

LLM / agent layer

[verify] Parse intent + entities (amount, recipient, payout method), handle Spanish/slang/voice; emit a structured transfer request.

Stripe Payments + Connect

[verify] Collect USD from the sender's card/bank; Connect orchestrates the multi-party money movement.

Bridge / Circle — USD↔USDC

[verify] Convert the funded USD to USDC and move value cross-border on stablecoin rails.

dLocal / Bitso — payout

[verify] Off-ramp USDC to local currency and disburse to the recipient's bank account or cash-pickup point.

Minimal integration

Illustrative: a WhatsApp webhook → AI intent parse → kick off a USDC-funded transfer (vendor calls stubbed; not Félix's real code).

// POST /webhooks/whatsapp — Meta delivers inbound messages here
export async function POST(req: Request) {
  const body = await req.json();
  const msg = body.entry?.[0]?.changes?.[0]?.value?.messages?.[0];
  if (!msg) return new Response('ok'); // status/read receipts, etc.

  const from = msg.from;                 // sender's WhatsApp number
  const text = msg.text?.body ?? (await transcribe(msg.audio)); // voice notes too

  // 1) AI layer turns free-form chat into a structured transfer
  const intent = await agent.parse({ from, text });
  if (intent.type !== 'SEND_MONEY') return reply(from, intent.reply);

  // gate the first send on KYC
  if (!(await kyc.isVerified(from))) return reply(from, await kyc.startFlow(from));

  // 2) FUND: pull USD from the sender (Stripe)
  const charge = await stripe.charge({ user: from, amount: intent.usd });

  // 3) SETTLE: USD -> USDC, move cross-border (Bridge/Circle)
  const transfer = await bridge.send({
    sourceCharge: charge.id,
    asset: 'USDC',
    amount: intent.usd,
    destination: intent.corridor,        // e.g. 'MX', 'GT', 'HN'
  });

  // 4) PAYOUT: USDC -> local currency, last-mile (dLocal/Bitso)
  const payout = await dlocal.payout({
    transferId: transfer.id,
    beneficiary: intent.recipient,       // bank account / cash pickup
    country: intent.corridor,
  });

  // 5) confirm back in the same WhatsApp thread
  return reply(from, `Sent! ${intent.recipient.name} gets it in ~2 min. Ref ${payout.id}`);
}

Build notes

• Treat the payout webhook/state — not the chat — as the source of truth; the transfer is a state machine (FUNDED → SETTLING → PAID / FAILED) and every leg must be idempotent so a retried WhatsApp message doesn't double-send.
• KYC/AML must gate the first transfer, and the multi-party money-transmitter setup is the real moat-and-cost center — far more than the chatbot.
• WhatsApp Cloud API has template/24-hour-session messaging rules and per-message pricing; design conversational flows around them.
• [verify] Félix exposes no public API or SDK — this surface is the composed building-block stack (WhatsApp + Stripe + Bridge/Circle + dLocal/Bitso), not a Félix product.