> ## Documentation Index
> Fetch the complete documentation index at: https://docs.laso.finance/llms.txt
> Use this file to discover all available pages before exploring further.

# Send a payment via Venmo or PayPal

> Send USDC from your agent's wallet to a Venmo or PayPal recipient using the Laso Finance send-payment endpoint and the x402 protocol.

## Overview

Your agent can send a payout to a Venmo or PayPal recipient using the `/send-payment` endpoint. The payment is funded with USDC on Base or Solana via x402 and delivered to the recipient's Venmo or PayPal account.

The endpoint requires identity verification (KYC) on the wallet that pays for the request. **Check `GET /get-kyc-status` first** (it's free): if the wallet isn't verified yet, complete verification before paying for a send. If you call `/send-payment` from an unverified wallet, the response returns `kyc_url` instead of dispatching the payout, and the USDC you already paid is credited to your account balance — verify and call again to send, or withdraw it back with `POST /withdraw`.

## How it works

**1. Agent calls /send-payment**

Your agent makes an x402 request to `GET /send-payment` with the platform,
recipient details, and amount. The x402 USDC price is the requested amount
plus a 4.9% fee (with a \$1.50 minimum).

**2. Laso checks the wallet's KYC status**

If the wallet is already verified, Laso debits the credited account balance
and dispatches the payout. If not, the response returns `kyc_required: true`
and a `kyc_url`.

**3. (If needed) Complete KYC and retry**

Open the `kyc_url`, complete the flow, then call `/send-payment` again with
a fresh x402 payment to send the payout.

**4. Funds arrive**

Venmo and PayPal payouts typically settle within minutes once dispatched.
Confirm with `GET /get-payment-status` (free).

> [!NOTE]
>
> A `kyc_required` response still settles your payment, which credits your Laso
> account balance, and you can recover the funds with `POST /withdraw`. An error
> response on an x402 payment means nothing settled, so the USDC is still in
> your wallet. MPP settles before the route runs, so the same error leaves it in
> your account balance.

## If verification is required

When the response contains `kyc_required: true`, the payout was **not** sent, but
the USDC you paid was still credited to the calling wallet's Laso account balance.
You have two ways forward, and no funds are at risk either way:

1. **Complete verification and retry.** Open the returned `kyc_url`, finish the
   identity flow, then call `/send-payment` again with a fresh x402 payment. The
   payout dispatches once the wallet is verified.
2. **Recover the funds.** If you don't want to verify, call `POST /withdraw` to
   send the credited USDC back to the wallet.

Verification is per-wallet and one-time: once a wallet is verified, future
`/send-payment` calls go straight through.

## Sending a payment

Venmo:

```bash theme={null}
curl "https://laso.finance/send-payment?platform=venmo&amount=25&recipient_id=5551234567&recipient_first_name=Jane&recipient_last_name=Doe" \
  -H "X-Payment: <x402-payment-header>"
```

PayPal:

```bash theme={null}
curl "https://laso.finance/send-payment?platform=paypal&amount=25&recipient_id=jane%40example.com&recipient_first_name=Jane&recipient_last_name=Doe" \
  -H "X-Payment: <x402-payment-header>"
```

| Parameter | Description |
| - | - |
| `platform` | `venmo` or `paypal`. |
| `amount` | USD amount to send to the recipient (min \$5, max \$1,000). A 4.9% fee with a \$1.50 minimum is added to compute USDC. |
| `recipient_id` | Venmo: recipient's 10-digit U.S. phone number. PayPal: recipient's email address. |
| `recipient_first_name` | Recipient's first name (English letters A-Z and a-z only). Required for PayPal, optional for Venmo. |
| `recipient_last_name` | Recipient's last name (English letters A-Z and a-z only). Required for PayPal, optional for Venmo. |
| `recipient_email` | PayPal only. Recipient's email; defaults to `recipient_id`. Not used for Venmo. |

## Response (verified wallet)

A dispatched payout answers `202 Accepted`, not `200`. The payment is recorded and handed to the payout provider, which settles it afterwards, so the 202 means the request was accepted rather than that the recipient has the money. A `200` here means the opposite: nothing was dispatched because identity verification is required.

```json theme={null}
{
  "auth": {
    "id_token": "eyJ...",
    "refresh_token": "AMf...",
    "expires_in": "3600"
  },
  "user_id": "0xabc...",
  "success": true,
  "message": "Payment is being processed.",
  "platform": "venmo",
  "amount": 25,
  "recipient_id": "5551234567",
  "payment_id": "abc123",
  "status_url": "https://laso.finance/get-payment-status?payment_id=abc123",
  "state": "in-process"
}
```

## Response (unverified wallet)

```json theme={null}
{
  "auth": {
    "id_token": "eyJ...",
    "refresh_token": "AMf...",
    "expires_in": "3600"
  },
  "user_id": "0xabc...",
  "kyc_required": true,
  "kyc_url": "https://api.sumsub.com/idensic/l/#/uni_...",
  "message": "KYC verification is required before sending Venmo or PayPal payouts. Complete the flow at kyc_url and retry, or call POST /withdraw to recover the funds credited to your account balance.",
  "platform": "venmo",
  "amount": 25,
  "recipient_id": "5551234567"
}
```

## Check the payout's status

`/send-payment` answers `202 Accepted` as soon as the payout is dispatched (`state: "in-process"`), not when the money lands. Its `status_url` is the free follow-up for that exact payout, and it points at `GET /get-payment-status` with the payout's `payment_id` already filled in. You can also call that route yourself: pass `payment_id` for one payout, `recipient_id` (from `GET /payment-recipients`) for one recipient's history, or nothing to list every payout the account has sent, newest first.

```bash theme={null}
curl "https://laso.finance/get-payment-status" \
  -H "Authorization: Bearer <id_token>"
```

```json theme={null}
{
  "payments": [
    {
      "id": "otlUYhH8n7Q2KWmt6FBs",
      "amount_pre_fees": 25,
      "amount_with_fees": 26.5,
      "fees_paid": 1.5,
      "platform": "venmo",
      "state": "complete",
      "state_updated_at": 1789365621369,
      "recipient_id": "Bh3bHdQwErTyUiOpAsDf",
      "recipient_first_name": "Jane",
      "recipient_last_name": "Doe",
      "timestamp": 1789364854261,
      "timestamp_readable": "9/14/2026, 6:47:34 AM"
    }
  ]
}
```

| State | Meaning |
| - | - |
| `queued` | Waiting for the account balance to cover it. Still in flight. |
| `awaiting-funding` | Debited and accepted, but delayed on our side before it reaches Venmo or PayPal. Usually sent by the next business day. Still in flight. |
| `in-process` | Handed to Venmo or PayPal. Normally completes within minutes. |
| `complete` | The recipient has the money. |
| `failed` | Not delivered. The debited balance is credited back. |
| `cancelled` | Not delivered. The debited balance is credited back. |

Poll every few minutes while a payout is `queued`, `awaiting-funding` or `in-process`, or [register a webhook](https://docs.laso.finance/guides/agent-webhooks.md) to be told when it completes. `state` is absent on payouts sent before state tracking existed.

## Saved recipients

Laso keeps a list of the Venmo and PayPal recipients this account has paid before, so your agent can turn "send \$20 to Jane" into a payout without asking for the phone number or email again. `GET /payment-recipients` lists them (free, Bearer token). Add `include_archived=true` to include archived entries.

```bash theme={null}
curl "https://laso.finance/payment-recipients?platform=venmo" \
  -H "Authorization: Bearer <id_token>"
```

```json theme={null}
{
  "user_id": "usr_...",
  "platform": "venmo",
  "recipients": [
    {
      "recipient_id": "aQ3xK9mZpL2vB7nR4tYw",
      "handle": "5551234567",
      "name": "Jane Doe",
      "display_name": "Jane (rent)",
      "status": "active",
      "total_sent": 450,
      "send_count": 6,
      "last_sent_timestamp": 1789000000000
    }
  ]
}
```

> [!WARNING]
>
> Two ids are in play. `handle` is the phone number or email you pay: pass it
> as `recipient_id` to `/send-payment`. The entry's own `recipient_id` is an
> opaque id for the saved entry: it is what `POST` and `DELETE
>     /payment-recipients` take, and what the `recipient_id` filter on
> `/get-payment-status` matches. Passing it to `/send-payment` does not send
> to the saved person.

`display_name` is the label the account owner chose, so use it when confirming an amount with them; `name` is the recipient's own name on the platform. When two entries have similar names, `total_sent` and `last_sent_timestamp` help tell them apart, and asking beats guessing.

To rename or archive an entry, send `POST /payment-recipients` with `platform`, the entry's `recipient_id`, and at least one of `display_name` or `archived`. Archiving hides the entry from the default list and keeps its history, so prefer it over deleting:

```bash theme={null}
curl -X POST "https://laso.finance/payment-recipients" \
  -H "Authorization: Bearer <id_token>" \
  -H "Content-Type: application/json" \
  -d '{"platform":"venmo","recipient_id":"aQ3xK9mZpL2vB7nR4tYw","archived":true}'
```

`DELETE /payment-recipients` with the same `platform` and `recipient_id` (in the query string or the JSON body) removes the entry. Payment history is kept, but the removal cannot be undone through the API, so confirm before removing someone your human did not ask you to remove.

## Tell your agent

> [accordion] Send \$25 via Venmo
>
> ```
> Send $25 to Jane Doe via Venmo using the Laso Finance API. Call GET
> https://laso.finance/send-payment with platform=venmo, amount=25,
> recipient_id=5551234567, recipient_first_name=Jane, recipient_last_name=Doe
> via x402. If the response includes kyc_required, give the kyc_url to the
> user, wait for verification, then retry.
> ```

> [accordion] Send \$50 via PayPal
>
> ```
> Send $50 to Jane Doe via PayPal using the Laso Finance API. Call GET
> https://laso.finance/send-payment with platform=paypal, amount=50,
> recipient_id=jane@example.com, recipient_first_name=Jane,
> recipient_last_name=Doe via x402. If the response includes kyc_required,
> surface the kyc_url, wait for verification, then retry.
> ```

> [accordion] Pay someone I have paid before
>
> ```
> Send $20 to Jane via Venmo using the Laso Finance API. First call GET
> https://laso.finance/payment-recipients?platform=venmo with my id_token and
> find the entry whose display_name or name matches Jane; if more than one
> matches, ask me which. Then call GET https://laso.finance/send-payment with
> platform=venmo, amount=20, and recipient_id set to that entry's handle (not
> its recipient_id) via x402.
> ```

## Fee structure

| Property | Value |
| - | - |
| Minimum amount | \$5 |
| Maximum amount | \$1,000 |
| Percentage fee | 4.9% on top of `amount` |
| Minimum fee | \$1.50 (applied when 4.9% of `amount` is below \$1.50) |
| USDC price formula | `max(amount × 1.049, amount + 1.50)` |

> [!WARNING]
>
> KYC verification is per-wallet. If you switch wallets, the new wallet has to
> complete its own verification before it can send Venmo or PayPal payouts.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.