> This is Payabli documentation. For a complete page index, fetch https://docs.payabli.com/llms.txt — append .md to any page URL for lightweight markdown. For section-level indexes, query parameters, and other AI-optimized access methods, see https://docs.payabli.com/ai-agents.md

# Pay Out cookbook

> Quickstart recipes for ACH, vCard, check, and managed payouts

Use these recipes to get started with Pay Out features and functions. See [Pay Out overview](/guides/pay-out-overview) for more.

New to the API? Start with the [authentication guide](/cookbooks/cookbooks-overview) on the cookbooks home.

<h3>Recipe: Make your first payout</h3>
/// Overview

This complete end-to-end workflow walks through how to send a payment to a vendor using ACH.

/// Step 1: Create a vendor

First, make sure that you have a vendor record. If you already have a `vendorNumber`, you can skip to step 2.

To create a vendor, send a POST request to `/api/Vendor/single/{entry}`.

```bash
curl -X POST "https://api.payabli.com/api/Vendor/single/your-entry-point" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "vendorNumber": "V-001",
    "name1": "My First Vendor",
    "email": "vendor@example.com",
    "paymentMethod": "ach",
    "vendorStatus": 1
  }'
```

You need the `vendorNumber` you set for the vendor in the next step.

See [Create vendor](/developers/api-reference/vendor/create-vendor) for the full API reference.

/// Step 2: Create a bill for the vendor

Send a POST request to `/api/Bill/single/{entry}` to add a bill that represents the invoice you need to pay. This is optional but **strongly** recommended for tracking.

```bash focus=5
curl -X POST "https://api.payabli.com/api/Bill/single/your-entry-point" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "billNumber": "Test-234782",
    "netAmount": 2500.00,
    "billDate": "2025-01-08",
    "dueDate": "2025-02-08",
    "comments": "Q1 supplies order",
    "vendor": {
        "vendorNumber": "V-001"
    }
  }'
```

The `billId` is returned in `responseData`. Copy this to use in the next step.

```json highlight=7
{
  "responseText": "Success",
  "responseCode": 1,
  "pageIdentifier": null,
  "roomId": 0,
  "isSuccess": true,
  "responseData": 6101
}
```

See [Create bill](/developers/api-reference/bill/add-bill) for the full API reference.

/// Step 3: Authorize the payout transaction

Authorizing a payout creates the transaction, which is captured for processing later.
Include `autoCapture: true` in the request body to automatically capture the payout transaction after authorization.

To authorize a payout, send a POST request to `/api/MoneyOut/authorize`.

```bash
curl -X POST "https://api.payabli.com/api/MoneyOut/authorize" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "entryPoint": "your-entry-point",
    "autoCapture": true,
    "paymentMethod": {
      "method": "ach", // For managed payouts, used 'managed' here, and omit ACH fields
      "achHolder": "My First Vendor",
      "achRouting": "021000021",
      "achAccount": "123456789",
      "achAccountType": "Checking"
    },
    "paymentDetails": {
      "totalAmount": 2500.00,
      "orderDescription": "First payout test"
    },
    "vendorData": {
      "vendorNumber": "V-001"
    },
    "invoiceData": [
      {
        "billId": 6101
      }
    ]
  }'
```

The response includes a `referenceId` (for example, `"129-001"`) that you need to capture the payout for processing in the next step.

```json highlight=9
{
  "responseCode": 1,
  "pageIdentifier": null,
  "roomId": 0,
  "isSuccess": true,
  "responseText": "Success",
  "responseData": {
    "authCode": null,
    "referenceId": "129-001",
    "resultCode": 1,
    "resultText": "Authorized",
    "avsResponseText": null,
    "cvvResponseText": null,
    "customerId": 0,
    "methodReferenceId": null
  }
}
```

See [Authorize a transaction for payout](/developers/api-reference/moneyout/authorize-a-transaction-for-payout) for the full API reference.

/// Step 4: Capture the payout for settlement

Capturing an authorized payout adds it to a batch for processing.
If you didn't set the `autoCapture` field to `true` in the payout authorization request, you need to capture the authorization manually.
If you set `autoCapture` to `true`, skip this step.

To capture the payout, send a GET request to `/api/MoneyOut/capture/{referenceId}`.

```bash
curl -X GET "https://api.payabli.com/api/MoneyOut/capture/129-001" \
  -H "requestToken: YOUR_API_TOKEN"
```

The payout is now captured and will process with the next batch at 5 PM ET.

See [Capture an authorized payout transaction](/developers/api-reference/moneyout/capture-an-authorized-payout-transaction) for the full API reference.

/// Step 5: Monitor transaction status

Check the transaction status as it progresses through the payment lifecycle.

To get the transaction details, send a GET request to `/api/MoneyOut/details/{referenceId}`.

```bash
curl -X GET "https://api.payabli.com/api/MoneyOut/details/129-001" \
  -H "requestToken: YOUR_API_TOKEN"
```

Watch for the status to progress: 1 (Captured) → 2 (Processing) → 3 (Processed) → 5 (Paid).

* Learn more about [Pay Out statuses](/guides/pay-out-status-reference).
* See [Get details for a processed payout transaction](/developers/api-reference/moneyout/get-details-for-a-processed-payout-transaction) for the full API reference.

/// What's next

Congratulations! You just processed your first payout. Next, get to know [payables](/guides/pay-out-payables-overview) and learn more about [managing payouts](/guides/pay-out-developer-payouts-manage).

<h3>Recipe: Create a vendor</h3>
/// Overview

Add a new vendor record with bank account details for ACH payments.

/// Prerequisites

Before you start, gather the following information. Payabli supports US and Canadian vendors only.

* Vendor business information: name, email, phone, and address
* A `vendorNumber` to identify the vendor in your system
* Bank account details for ACH payments: routing number, account number, account type, and account holder name

Including bank account details in `billingData` is not supported if you use [managed payouts](/guides/pay-out-managed-payables-overview).

/// Step 1: Create the vendor

Send a POST request to `/api/Vendor/single/{entry}` to create the vendor. The `entry` parameter is your entrypoint identifier.

```bash
curl -X POST "https://api.payabli.com/api/Vendor/single/your-entry-point" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "vendorNumber": "V-001",
    "name1": "Acme Supplies Inc",
    "email": "ap@acme.com",
    "phone": "5125551234",
    "address1": "123 Main Street",
    "city": "Austin",
    "state": "TX",
    "zip": "78701",
    "country": "US",
    "paymentMethod": "ach",
    "vendorStatus": 1,
    "billingData": {
      "routingAccount": "021000021",
      "accountNumber": "123456789",
      "typeAccount": "Checking",
      "bankAccountHolderName": "Acme Supplies Inc",
      "bankAccountHolderType": "Business",
      "bankName": "Chase Bank"
    }
  }'
```

The response returns the Payabli-generated `vendorId` in `responseData`.

```json highlight=5
{
  "responseText": "Success",
  "isSuccess": true,
  "responseCode": 1,
  "responseData": 3890
}
```

See [Create vendor](/developers/api-reference/vendor/create-vendor) for the full API reference.

<h3>Recipe: Create ACH payout</h3>
/// Overview

Send a payment to a vendor via ACH bank transfer with full transaction lifecycle. This recipe is for on-demand payouts and is not supported with [managed payouts](/guides/pay-out-managed-payables-overview).

/// Prerequisites

Before you start, make sure you have the following:

* A `vendorNumber` for the vendor you're paying
* The vendor's ACH information: account holder name, routing number, account number, and account type (checking or savings)
* A `billId` if you're paying against a bill (recommended)

/// Step 1: Authorize the payout

Authorize the payout. This queues the transaction but doesn't process it until captured.

To authorize a payout, send a POST request to `/api/MoneyOut/authorize`.

```bash
curl -X POST "https://api.payabli.com/api/MoneyOut/authorize" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "entryPoint": "your-entry-point",
    "autoCapture": true,
    "paymentMethod": {
      "method": "ach",
      "achHolder": "Acme Supplies",
      "achRouting": "021000021",
      "achAccount": "123456789",
      "achAccountType": "Checking"
    },
    "paymentDetails": {
      "totalAmount": 1500.00,
      "orderDescription": "Invoice payment"
    },
    "vendorData": {
      "vendorNumber": "V-001"
    },
    "invoiceData": [
      {
        "billId": 6101
      }
    ]
  }'
```

The response includes a `referenceId` that you need to cancel a transaction or check its details.

```json highlight=5
{
  "isSuccess": true,
  "responseData": {
    "authCode": null,
    "referenceId": "129-219",
    "resultCode": 1,
    "resultText": "Authorized"
  }
}
```

See [Authorize a transaction for payout](/developers/api-reference/moneyout/authorize-a-transaction-for-payout) for the full API reference.

/// Step 2: Monitor transaction status

Check the transaction details to monitor the payout through its lifecycle: Captured → Processing → Processed → Paid.

To get the transaction details, send a GET request to `/api/MoneyOut/details/{referenceId}`.

```bash
curl -X GET "https://api.payabli.com/api/MoneyOut/details/129-219" \
  -H "requestToken: YOUR_API_TOKEN"
```

See [Get details for a processed payout transaction](/developers/api-reference/moneyout/get-details-for-a-processed-payout-transaction) for the full API reference.

/// Step 3: (Optional) Cancel if needed

You can cancel authorized or captured transactions before the batch closes at 5 PM ET.

To cancel a payout, send a DELETE request to `/api/MoneyOut/cancel/{referenceId}`.

```bash focus=1
curl -X DELETE "https://api.payabli.com/api/MoneyOut/cancel/129-219" \
  -H "requestToken: YOUR_API_TOKEN"
```

See [Cancel a payout transaction](/developers/api-reference/moneyout/cancel-a-payout-transaction) for the full API reference.

<h3>Recipe: Create vCard payout</h3>
/// Overview

This recipe walks through issuing a single-use virtual card to a vendor and sending the card link via email. This recipe is for on-demand payouts and is not supported with [managed payouts](/guides/pay-out-managed-payables-overview).

/// Prerequisites

Before you start, make sure you have the following:

* A `vendorNumber` for the vendor you're paying
* The vendor's email address to send the card link to

/// Step 1: Create the virtual card payout

Authorize a payout with `method: "vcard"`. This creates a single-use virtual card for the vendor.

To authorize the payout, send a POST request to `/api/MoneyOut/authorize`.

```bash focus=7
curl -X POST "https://api.payabli.com/api/MoneyOut/authorize" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "entryPoint": "your-entry-point",
    "autoCapture": true,
    "paymentMethod": {
      "method": "vcard"
    },
    "paymentDetails": {
      "totalAmount": 500.00
    },
    "vendorData": {
      "vendorNumber": "V-001",
      "email": "vendor@example.com"
    }
  }'
```

The response includes a `referenceId` that you can use to cancel the transaction or check its details.

```json highlight=5
{
  "isSuccess": true,
  "responseData": {
    "authCode": null,
    "referenceId": "129-220",
    "resultCode": 1,
    "resultText": "Authorized"
  }
}
```

See [Authorize a transaction for payout](/developers/api-reference/moneyout/authorize-a-transaction-for-payout) for the full API reference.

/// Step 2: Send the card link

Send the vendor an email with a secure link to view their virtual card details.

To send the card link, send a POST request to `/api/vcard/send-card-link`.

```bash
curl -X POST "https://api.payabli.com/api/vcard/send-card-link" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "transId": "129-220"
  }'
```

See [Send vCard link](/developers/api-reference/moneyout/send-vcard-link) for the full API reference.

/// Step 3: Monitor for payment

When the vendor uses the vCard, the transaction status changes to Paid. vCards remain open for 180 days if not used.

Learn more about [Pay Out statuses](/guides/pay-out-status-reference).

<h3>Recipe: Create check payout</h3>
/// Overview

Send a physical check payment to a vendor with the authorize-and-capture workflow. This recipe is for on-demand payouts and isn't supported with [managed payouts](/guides/pay-out-managed-payables-overview).

/// Prerequisites

Before you start, make sure you have the following:

* A `vendorNumber` for the vendor you're paying
* The vendor record must have `payeeName1` set — this is the name printed on the check
* A `billId` if you're paying against a bill (strongly recommended)

/// Step 1: Authorize the payout

Authorize a payout with `method: "check"`. This queues the transaction but doesn't process it until it's captured.

To authorize a payout, send a POST request to `/api/MoneyOut/authorize`.

```bash highlight=7,11
curl -X POST "https://api.payabli.com/api/MoneyOut/authorize" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "entryPoint": "your-entry-point",
    "autoCapture": true,
    "paymentMethod": {
      "method": "check"
    },
    "paymentDetails": {
      "totalAmount": 1500.00,
      "checkNumber": "10001"
    },
    "vendorData": {
      "vendorNumber": "V-001"
    },
    "invoiceData": [
      {
        "billId": 6101
      }
    ]
  }'
```

The `checkNumber` field is optional. If you don't include one, Payabli automatically manages check numbering and sequencing.

The response includes a `referenceId` that you need to cancel the transaction or check its details.

```json highlight=5
{
  "isSuccess": true,
  "responseData": {
    "authCode": null,
    "referenceId": "129-221",
    "resultCode": 1,
    "resultText": "Authorized"
  }
}
```

See [Authorize a transaction for payout](/developers/api-reference/moneyout/authorize-a-transaction-for-payout) for the full API reference.

/// Step 2: Monitor transaction status

Check the transaction details to monitor the payout through its lifecycle: Captured → Processing → Processed → Paid.

To get the transaction details, send a GET request to `/api/MoneyOut/details/{referenceId}`.

```bash
curl -X GET "https://api.payabli.com/api/MoneyOut/details/129-221" \
  -H "requestToken: YOUR_API_TOKEN"
```

See [Get details for a processed payout transaction](/developers/api-reference/moneyout/get-details-for-a-processed-payout-transaction) for the full API reference.

/// Step 3: (Optional) Cancel if needed

You can cancel authorized or captured transactions before the batch closes at 5 PM ET. Once the status changes to Processed, you can't cancel the transaction.

To cancel a payout, send a DELETE request to `/api/MoneyOut/cancel/{referenceId}`.

```bash
curl -X DELETE "https://api.payabli.com/api/MoneyOut/cancel/129-221" \
  -H "requestToken: YOUR_API_TOKEN"
```

See [Cancel a payout transaction](/developers/api-reference/moneyout/cancel-a-payout-transaction) for the full API reference.

/// What's next

You've created a physical check payout. Learn about [retrieving check images](/guides/pay-out-developer-checks-get-image) for record-keeping, or set up [Positive Pay](/guides/pay-out-checks-positive-pay) for fraud prevention.

<h3>Recipe: Pay a vendor with a saved ACH method</h3>
/// Overview

Pay a vendor using an ACH method already stored on their vendor record, without re-collecting their banking details. This recipe is for on-demand payouts and isn't supported with [managed payouts](/guides/pay-out-managed-payables-overview).

/// Prerequisites

Before you start, make sure you have the following:

* A `vendorNumber` for the vendor you're paying
* A `storedMethodId` (the `idPmethod` value) from the vendor's `storedMethods` array. To retrieve it, send a GET request to `/api/Vendor/{idVendor}` and copy the `idPmethod` of the ACH method you want to use.
* Your paypoint's `entryPoint` value
* A `billId` if you're paying against a bill (recommended)

If the vendor has exactly one stored ACH method, `storedMethodId` is optional — Payabli uses that method by default. If the vendor has multiple stored ACH methods, `storedMethodId` is required.

/// Step 1: Authorize the payout

Authorize the payout with `paymentMethod.method` set to `ach` and the vendor's `storedMethodId`. Set `autoCapture` to `true` to capture the transaction immediately after authorization.

Send a POST request to `/api/MoneyOut/authorize`.

```bash focus=9-10
curl -X POST "https://api.payabli.com/api/MoneyOut/authorize" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "entryPoint": "your-entry-point",
    "autoCapture": true,
    "source": "api",
    "paymentMethod": {
      "method": "ach",
      "storedMethodId": "4c6a4b78-72de-4bdd-9455-b9d30f991001-XXXX"
    },
    "paymentDetails": {
      "totalAmount": 47.00
    },
    "vendorData": {
      "vendorNumber": "V-001"
    },
    "invoiceData": [
      {
        "billId": 54323
      }
    ]
  }'
```

The response includes a `referenceId` that you need to check the transaction's details or cancel it.

```json highlight=5
{
  "isSuccess": true,
  "responseData": {
    "authCode": null,
    "referenceId": "129-219",
    "resultCode": 1,
    "resultText": "Authorized"
  }
}
```

See [Authorize a transaction for payout](/developers/api-reference/moneyout/authorize-a-transaction-for-payout) for the full API reference.

/// Step 2: Check the transaction status

Use the `referenceId` from the previous step to monitor the payout through its lifecycle: Captured → Processing → Processed → Paid.

Send a GET request to `/api/MoneyOut/details/{referenceId}`.

```bash
curl -X GET "https://api.payabli.com/api/MoneyOut/details/129-219" \
  -H "requestToken: YOUR_API_TOKEN"
```

See [Get details for a processed payout transaction](/developers/api-reference/moneyout/get-details-for-a-processed-payout-transaction) for the full API reference.

/// What's next

Congratulations! You just paid a vendor with a saved ACH method. Next, learn how to [manage payouts](/guides/pay-out-developer-payouts-manage) and explore [vendor payment links](/guides/pay-out-developer-payment-links-manage) for collecting and saving new vendor methods.

<h3>Recipe: Approve and pay a bill</h3>
/// Overview

Route a bill through approval and make a payout. This recipe covers the approval workflow from submission to payout.

/// Prerequisites

Before you start, make sure you have the following:

* An existing bill with its `idBill` — see [Create bill](/developers/api-reference/bill/add-bill) or the [manage bills guide](/guides/pay-out-developer-bills-manage)
* The vendor's payment information (ACH details or stored method)
* Approver email addresses for your approval workflow

/// Step 1: Send the bill for approval

Submit the bill to one or more approvers by passing an array of their email addresses. The bill status changes to "Sent to Approval".

Send a POST request to `/api/Bill/approval/{idBill}`.

```bash
curl -X POST "https://api.payabli.com/api/Bill/approval/6101" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '["approver1@company.com", "approver2@company.com"]'
```

See [Send bill for approval](/developers/api-reference/bill/send-a-bill-to-approval) for the full API reference.

/// Step 2: Approve or reject the bill

Approvers can approve or reject the bill through the Payabli Portal or through the API. To approve or reject programmatically, use `true` to approve or `false` to reject.

Send a GET request to `/api/Bill/approval/{idBill}/{approved}`.

```bash
curl -X GET "https://api.payabli.com/api/Bill/approval/6101/true" \
  -H "requestToken: YOUR_API_TOKEN"
```

See [Approve bill](/developers/api-reference/bill/approve-or-disapprove-a-bill) for the full API reference.

/// Step 3: Verify the bill status

Confirm the bill is approved and ready for payout.

Send a GET request to `/api/Bill/{idBill}`.

```bash
curl -X GET "https://api.payabli.com/api/Bill/6101" \
  -H "requestToken: YOUR_API_TOKEN"
```

Check the `Status` field in the response. A status of `1` (Active) or `20` (Approved) means the bill is ready for payout.

See [Get bill](/developers/api-reference/bill/get-bill) for the full API reference.

/// Step 4: Authorize the payout

Create a payout authorization that references the approved bill.

Send a POST request to `/api/MoneyOut/authorize`.

```bash highlight=21
curl -X POST "https://api.payabli.com/api/MoneyOut/authorize" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "entryPoint": "your-entry-point",
    "paymentMethod": {
      "method": "ach",
      "achHolder": "Acme Supplies",
      "achRouting": "021000021",
      "achAccount": "123456789",
      "achAccountType": "Checking"
    },
    "paymentDetails": {
      "totalAmount": 2500.00
    },
    "vendorData": {
      "vendorNumber": "1234-A"
    },
    "invoiceData": [
      {
        "billId": 6101
      }
    ]
  }'
```

The response includes a `referenceId` that you need to capture the payout.

```json highlight=4
{
  "isSuccess": true,
  "responseData": {
    "referenceId": "129-230",
    "resultCode": 1,
    "resultText": "Authorized"
  }
}
```

See [Authorize payout](/developers/api-reference/moneyout/authorize-a-transaction-for-payout) for the full API reference.

/// Step 5: Capture the payout

Capture the authorized transaction to process the payment.

Send a GET request to `/api/MoneyOut/capture/{referenceId}`.

```bash
curl -X GET "https://api.payabli.com/api/MoneyOut/capture/129-230" \
  -H "requestToken: YOUR_API_TOKEN"
```

See [Capture payout](/developers/api-reference/moneyout/capture-an-authorized-payout-transaction) for the full API reference.

/// What's next

You've approved and paid a bill. Learn more about [managing bills with the API](/guides/pay-out-developer-bills-manage) and explore the [ACH payout recipe](/cookbooks/cookbooks-overview) for more payout options.

<h3>Recipe: Send a vendor payment link</h3>
/// Overview

Generate a payment link for a bill and send it to a vendor via email. The vendor selects their preferred payout method (ACH, virtual card, or check) on a secure, hosted page. When they complete it, Payabli automatically authorizes and captures the payout.

/// Prerequisites

Before you start, make sure you have the following:

* A vendor associated with the bill. If you haven't created one yet, see [Manage vendors](/guides/pay-out-developer-vendors-manage).
* A `billId` for an existing bill. If you haven't created one yet, see [Manage bills](/guides/pay-out-developer-bills-manage).
* The vendor's email address
* Your paypoint's available payout methods (ACH, virtual card, check)

/// Step 1: Generate the payment link

Create a payment link tied to the bill. Don't include the `mail2` query parameter — you'll send the link in the next step instead.

Send a POST request to `/api/PaymentLink/bill/{billId}`.

```bash
curl -X POST "https://api.payabli.com/api/PaymentLink/bill/23548884" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "page": {
      "enabled": true,
      "header": "Payment Page",
      "description": "Get paid securely",
      "order": 0
    },
    "paymentButton": {
      "enabled": true,
      "label": "Pay Now",
      "order": 0
    },
    "paymentMethods": {
      "enabled": true,
      "header": "Payment Methods",
      "allMethodsChecked": true,
      "allowMultipleMethods": true,
      "defaultMethod": "vcard",
      "methods": {
        "ach": true,
        "vcard": true,
        "check": true
      },
      "order": 0
    }
  }'
```

The response includes the payment link ID. Save this — you'll need it to send the link in the next step.

```json highlight=3
{
  "isSuccess": true,
  "responseData": "2325-XXXXXXX-90b1-4598-b6c7-44cdcbf495d7-1234",
  "responseText": "Success"
}
```

See [Generate payment link from bill](/developers/api-reference/paymentlink/generate-payment-link-from-bill) for the full API reference.

/// Step 2: Send the payment link

Send the link to the vendor's email. To send to additional recipients beyond the vendor's email on file, add their addresses to the `mail2` query parameter, separated by semicolons.

Send a GET request to `/api/PaymentLink/send/{payLinkId}`.

```bash
curl -X GET "https://api.payabli.com/api/PaymentLink/send/2325-XXXXXXX-90b1-4598-b6c7-44cdcbf495d7-1234?mail2=ap@vendor.com;billing@vendor.com" \
  -H "requestToken: YOUR_API_TOKEN"
```

See [Send payment link](/developers/api-reference/paymentlink/send-payment-link) for the full API reference.

/// What's next

Congratulations! You just sent a vendor payment link. The vendor's payment method preference is stored automatically for future payouts. Learn more about [managing vendor payment links](/guides/pay-out-developer-payment-links-manage) and [managing payouts](/guides/pay-out-developer-payouts-manage).

<h3>Recipe: Reissue a payout</h3>
/// Overview

Reissue a payout transaction with a different payment method when the original can't be completed. This recipe covers reissuing as ACH, check, or virtual card. Reissuing is for on-demand payouts only — it isn't supported with [managed payouts](/guides/pay-out-managed-payables-overview).

/// Prerequisites

Before you start, make sure you have the following:

* The `transId` of the original payout transaction
* The original transaction must be in **Processing** or **Processed** status
* The new payment method details (ACH bank account details, or just the method type for check or virtual card)
* If the original was a check, contact Payabli support to stop the original check before reissuing

/// Step 1: Reissue the payout

Send a POST request to `/api/MoneyOut/reissue` with the original transaction ID as a query parameter and the new payment method in the request body.

The example below reissues a payout as ACH. For check, set `method` to `"check"` (no additional fields needed — the check is mailed to the remittance address from the original transaction). For virtual card, set `method` to `"vcard"`.

```bash
curl -X POST "https://api.payabli.com/api/MoneyOut/reissue?transId=129-219" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "paymentMethod": {
      "method": "ach",
      "achAccount": "9876543210",
      "achAccountType": "savings",
      "achRouting": "021000021",
      "achHolder": "Acme Corp",
      "achHolderType": "business"
    }
  }'
```

A successful response returns the new transaction ID and a link to the original transaction.

```json highlight=4
{
  "isSuccess": true,
  "responseData": {
    "transactionId": "130-220",
    "status": "Authorized",
    "originalTransactionId": "129-219"
  }
}
```

The new transaction goes through the standard authorize-and-capture flow automatically. Check the `isSuccess` field in the response — an HTTP 200 doesn't always mean the reissue succeeded.

See [Reissue payout](/developers/api-reference/moneyout/reissue-a-payout-transaction) for the full API reference.

/// Step 2: Verify the reissue

Check the new transaction's details to confirm it was created and monitor its progress through the lifecycle.

Send a GET request to `/api/MoneyOut/details/{transId}`, using the `transactionId` from the reissue response.

```bash
curl -X GET "https://api.payabli.com/api/MoneyOut/details/130-220" \
  -H "requestToken: YOUR_API_TOKEN"
```

The response includes an `Events` array that links back to the original transaction for audit purposes.

See [Get details for a processed payout transaction](/developers/api-reference/moneyout/get-details-for-a-processed-payout-transaction) for the full API reference.

/// What's next

You've reissued a payout with a new payment method. Learn more about [reissue rules and error handling](/guides/pay-out-developer-payouts-reissue) and the [payout transaction lifecycle](/guides/pay-out-payables-overview).

<h3>Recipe: Cancel a payout</h3>
/// Overview

Cancel an authorized or captured payout before it processes. Pay Out transactions don't support refunds, so once a payout reaches `processed`, you can't reverse it. If you need to resend the payout with a different payment method, [reissue it](/guides/pay-out-developer-payouts-reissue) instead.

/// Prerequisites

Before you start, make sure you have the following:

* The `referenceId` of the payout transaction you want to cancel.
* Confirmation that the transaction is still authorized or captured. You can't cancel a payout that has already processed.

You can cancel an authorized payout at any time. After a payout is captured, you have a small window to cancel it before the batch closes.

/// Cancel the payout

Send a DELETE request to `/api/MoneyOut/cancel/{referenceId}`.

```bash focus=1
curl -X DELETE "https://api.payabli.com/api/MoneyOut/cancel/129-219" \
  -H "requestToken: YOUR_API_TOKEN"
```

A successful request returns a 200 response with the canceled transaction's `responseData.ReferenceId`.

```json highlight=5
{
  "isSuccess": true,
  "responseText": "Success",
  "responseData": {
    "ReferenceId": "129-219",
    "ResultCode": 1,
    "ResultText": "Approved",
    "CustomerId": 0
  }
}
```

To cancel several payouts in one request, send a POST request to `/api/MoneyOut/cancelAll` with an array of reference IDs instead.

See [Cancel payout](/developers/api-reference/moneyout/cancel-a-payout-transaction) for the full API reference.

/// What's next

You just canceled a payout. Learn how to [reissue a payout](/guides/pay-out-developer-payouts-reissue) if you need to resend the payment, or review the full [payout lifecycle](/guides/pay-out-developer-payouts-manage) to understand when cancellation is available.

<h3>Recipe: Create a managed payout</h3>
/// Overview

Create a payout where Payabli's vendor enablement team contacts the vendor and determines the best payment method. For more details on the enablement process, see [Managed payables overview](/guides/pay-out-managed-payables-overview).

/// Prerequisites

Before you start, make sure you have the following:

* A `vendorNumber` for the vendor you're paying
* The vendor's contact name, phone number, and email address on their vendor record — the vendor enablement team needs these to reach the vendor
* A remittance address for the vendor, in case the payment falls back to a physical check

/// Step 1: Create a bill

Add a bill that represents the invoice you need to pay. This step is optional but **strongly** recommended for tracking. If you already have a `billId`, skip to step 2.

To create a bill, send a POST request to `/api/Bill/single/{entry}`.

```bash
curl -X POST "https://api.payabli.com/api/Bill/single/your-entry-point" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "billNumber": "INV-12345",
    "netAmount": 1500.00,
    "billDate": "2025-01-08",
    "dueDate": "2025-02-08",
    "comments": "Q1 office supplies",
    "vendor": {
      "vendorNumber": "V-001"
    }
  }'
```

The `billId` is returned in `responseData`. Copy this to use in the next step.

```json highlight=7
{
  "responseText": "Success",
  "responseCode": 1,
  "pageIdentifier": null,
  "roomId": 0,
  "isSuccess": true,
  "responseData": 54323
}
```

See [Create bill](/developers/api-reference/bill/add-bill) for the full API reference.

/// Step 2: Authorize the payout

Authorize the payout with `method: "managed"`. This tells Payabli to handle vendor enablement and payment method selection automatically.

To authorize a payout, send a POST request to `/api/MoneyOut/authorize`.

```bash highlight=7
curl -X POST "https://api.payabli.com/api/MoneyOut/authorize" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "entryPoint": "your-entry-point",
    "autoCapture": true,
    "paymentMethod": {
      "method": "managed"
    },
    "paymentDetails": {
      "totalAmount": 1500.00,
      "orderDescription": "Q1 office supplies"
    },
    "vendorData": {
      "vendorNumber": "V-001"
    },
    "invoiceData": [
      {
        "billId": 54323
      }
    ]
  }'
```

The response includes a `referenceId` that you need to check the transaction's details.

```json highlight=9
{
  "responseCode": 1,
  "pageIdentifier": null,
  "roomId": 0,
  "isSuccess": true,
  "responseText": "Success",
  "responseData": {
    "authCode": null,
    "referenceId": "129-219",
    "resultCode": 1,
    "resultText": "Authorized",
    "avsResponseText": null,
    "cvvResponseText": null,
    "customerId": 0,
    "methodReferenceId": null
  }
}
```

See [Authorize payout](/developers/api-reference/moneyout/authorize-a-transaction-for-payout) for the full API reference.

/// Step 3: Monitor transaction status

Check the transaction status as it progresses through the managed payables lifecycle.

To get the transaction details, send a GET request to `/api/MoneyOut/details/{referenceId}`.

```bash
curl -X GET "https://api.payabli.com/api/MoneyOut/details/129-219" \
  -H "requestToken: YOUR_API_TOKEN"
```

Watch for the status to progress: 1 (Captured) → 2 (Processing) → 3 (Processed) → 5 (Paid).

* Learn more about [Pay Out statuses](/guides/pay-out-status-reference).
* See [Get payout details](/developers/api-reference/moneyout/get-details-for-a-processed-payout-transaction) for the full API reference.

/// What's next

You just created a managed payout. Next, learn more about the [vendor enablement process](/guides/pay-out-managed-payables-overview) and how to [manage payouts](/guides/pay-out-developer-payouts-manage).

<h3>Recipe: Create a ghost card</h3>
/// Overview

This recipe walks through creating a ghost card, a multi-use virtual debit card issued to a vendor for recurring or discretionary spend. Unlike single-use virtual cards, ghost cards aren't tied to a specific payout and can be reused within configurable spending limits.

/// Prerequisites

Before you start, make sure you have the following:

* A `vendorId` for the vendor receiving the card. The vendor must belong to the paypoint and have an active status. Only one ghost card can exist per vendor per paypoint.
* An `expenseLimit` value that doesn't exceed the paypoint's configured payout credit limit.

/// Step 1: Create the ghost card

Send a POST request to `/api/MoneyOutCard/GhostCard/{entry}` with the vendor ID and spending controls. Most fields are required. Optional fields are `expirationDate`, `mcc`, `tcc`, `misc1`, and `misc2`.

```bash
curl -X POST "https://api.payabli.com/api/MoneyOutCard/GhostCard/your-entry-point" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "vendorId": 42,
    "expenseLimit": 500.00,
    "amount": 500.00,
    "maxNumberOfUses": 3,
    "exactAmount": false,
    "expenseLimitPeriod": "monthly",
    "billingCycle": "monthly",
    "billingCycleDay": "1",
    "dailyTransactionCount": 5,
    "dailyAmountLimit": 200.00,
    "transactionAmountLimit": 100
  }'
```

The response includes a `ReferenceId` in `responseData`. This is the card token. Store it to reference the card in subsequent operations.

```json highlight=4
{
  "isSuccess": true,
  "responseData": {
    "ReferenceId": "gc_abc123def456",
    "ResultCode": 1,
    "ResultText": "Ghost Card created"
  }
}
```

See [Create ghost card](/developers/api-reference/cards/create-ghost-card) for the full API reference.

/// Step 2: (Optional) Update the card status

If you need to suspend or cancel the card, send a PATCH request to `/api/MoneyOutCard/card/{entry}` with the card token and the new status.

```bash
curl -X PATCH "https://api.payabli.com/api/MoneyOutCard/card/your-entry-point" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "cardToken": "gc_abc123def456",
    "status": "Inactive"
  }'
```

Valid status transitions:

* `Active` can change to `Inactive`, `Cancelled`, or `Expired`
* `Inactive` can change to `Active`
* `Expired` can change to `Active` (renews the card)
* `Cancelled` is terminal and can't be changed

See [Update card status](/developers/api-reference/cards/update-card-status) for the full API reference.

/// What's next

You've created a ghost card with spending controls. Learn more about [managing ghost cards](/guides/pay-out-developer-ghost-cards-manage) and the [Pay Out overview](/guides/pay-out-overview).

<h3>Recipe: Set up recurring vendor payouts</h3>
/// Overview

Set up a recurring payout subscription so a vendor is paid the same amount on a regular schedule. This recipe uses vCard, but ACH and check are also supported. Payout subscriptions aren't supported with [managed payouts](/guides/pay-out-managed-payables-overview).

/// Prerequisites

Before you start, make sure you have the following:

* Your paypoint's `entryPoint` value
* A `vendorId` or `vendorNumber` for the vendor you're paying. If you haven't created one yet, see the "Create a vendor" recipe in the [Pay Out cookbook](/cookbooks/pay-out).
* A schedule: start date, end date (or `untilcancelled`), and frequency (`weekly`, `monthly`, `annually`, etc.)
* The recurring amount you'll pay each cycle

/// Step 1: Create the payout subscription

Send a POST request to `/api/PayoutSubscription` with the vendor, payment method, schedule, and amount. If you omit `billData` and don't set `doNotCreateBills` to `true`, the system creates a bill automatically for each scheduled run.

```bash focus=16-20
curl -X POST "https://api.payabli.com/api/PayoutSubscription" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "entryPoint": "your-entry-point",
    "paymentMethod": {
      "method": "vcard"
    },
    "paymentDetails": {
      "totalAmount": 250,
      "serviceFee": 0
    },
    "vendorData": {
      "vendorId": 1501
    },
    "scheduleDetails": {
      "startDate": "09/01/2026",
      "endDate": "untilcancelled",
      "frequency": "monthly"
    }
  }'
```

A successful response includes the new payout subscription's ID in `responseData`. Save it. You'll need it to retrieve, pause, update, or delete the subscription later.

```json highlight=4
{
  "responseText": "Success",
  "isSuccess": true,
  "responseData": 42,
  "customerId": 1501
}
```

See [Create payout subscription](/developers/api-reference/payout-subscription/create-payout-subscription) for the full API reference.

/// Step 2: Confirm the subscription

Verify the subscription was created correctly by retrieving it. Use the `responseData` value from the previous step as the `id` path parameter.

Send a GET request to `/api/PayoutSubscription/{id}`.

```bash
curl -X GET "https://api.payabli.com/api/PayoutSubscription/42" \
  -H "requestToken: YOUR_API_TOKEN"
```

The response includes the schedule, payment method, vendor details, and the `nextDate` field showing when the next scheduled payout will run. Payout subscription transactions typically run between 2:30 AM and 3:30 AM Eastern time on the scheduled date. A `status` of `1` means active, and `0` means paused.

See [Get payout subscription](/developers/api-reference/payout-subscription/get-payout-subscription) for the full API reference.

/// Step 3: (Optional) Pause or unpause

To temporarily stop future payouts without deleting the subscription, send a PUT request to `/api/PayoutSubscription/{id}` with `setPause` set to `true`. The next payment date isn't calculated automatically while paused. To resume, send another PUT request with `setPause` set to `false`.

```bash focus=4
curl -X PUT "https://api.payabli.com/api/PayoutSubscription/42" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{ "setPause": true }'
```

See [Update payout subscription](/developers/api-reference/payout-subscription/update-payout-subscription) for the full API reference.

/// Step 4: (Optional) Update the schedule or amount

To change the recurring amount, schedule, or payment method, send a PUT request to `/api/PayoutSubscription/{id}` with the fields you want to update. Include only the fields you're changing.

```bash
curl -X PUT "https://api.payabli.com/api/PayoutSubscription/42" \
  -H "Content-Type: application/json" \
  -H "requestToken: YOUR_API_TOKEN" \
  -d '{
    "paymentDetails": {
      "totalAmount": 750,
      "serviceFee": 0
    },
    "scheduleDetails": {
      "startDate": "01/01/2027",
      "endDate": "12/31/2027",
      "frequency": "monthly"
    }
  }'
```

See [Update payout subscription](/developers/api-reference/payout-subscription/update-payout-subscription) for the full API reference.

/// What's next

Congratulations! You just set up recurring vendor payouts. To dive deeper into managing the subscription lifecycle, see [Manage payout subscriptions with the API](/guides/pay-out-developer-payout-subscriptions-manage). To cancel a subscription entirely, send a DELETE request to `/api/PayoutSubscription/{id}`.

<h3>Recipe: Retrieve payout batches and transfers</h3>
/// Overview

Retrieve a list of payout batches and outbound transfers for a paypoint to monitor Pay Out funding and settlement activity. For Pay Out, a **batch** is a group of payout transactions funded and processed together, and an outbound **transfer** records the movement of funds that settle those payouts.

/// Prerequisites

Before you start, make sure you have the following:

* Your paypoint's `entrypoint` identifier
* An API token with access to the paypoint. See the [authentication recipe](/cookbooks/cookbooks-overview?recipe=Authentication%20guide) for help

/// Step 1: Get payout batches for the paypoint

Query the batches endpoint to retrieve payout batches for a paypoint. Each batch groups payout transactions and reports the amount and record count for each payment method.

Send a GET request to `/api/Query/batchesOut/{entry}`.

```bash
curl -X GET "https://api.payabli.com/api/Query/batchesOut/your-entry-point?limitRecord=20&fromRecord=0" \
  -H "requestToken: YOUR_API_TOKEN"
```

The response includes batch records. Track a batch through its lifecycle with `BatchStatus`: Open (0) → Closed (1) → Funded (2) → Processed (3) → Paid (4). `BatchStatusText` returns the most recent event for that status.

```json highlight=15-16
{
  "Summary": {
    "totalRecords": 12,
    "totalAmount": 8450.00,
    "totalNetAmount": 8412.50,
    "totalPages": 1,
    "pageSize": 20
  },
  "Records": [
    {
      "IdBatch": 239,
      "BatchNumber": "892-20250115-SOLIDROCK",
      "BatchDate": "2025-01-15T00:00:00Z",
      "BatchAmount": 2847.50,
      "BatchStatus": 2,
      "BatchStatusText": "Funded",
      "BatchRecords": 4,
      "AchAmount": 1500.00,
      "AchRecords": 2,
      "CheckAmount": 847.50,
      "CheckRecords": 1,
      "VcardAmount": 500.00,
      "VcardRecords": 1,
      "PaypointId": 892,
      "PaypointDba": "Solid Rock Coatings"
    }
  ]
}
```

See [List payout batches for paypoint](/developers/api-reference/query/get-list-of-moneyout-batches-for-an-entrypoint) for the full API reference.

/// Step 2: Get outbound transfers for the paypoint

Query the outbound transfers endpoint to get fund-movement records with deductions like returns, holds, and billing fees. Each transfer ties back to a batch through `batchId` and `batchNumber`.

Send a GET request to `/api/Query/transfersOut/{entry}`.

```bash
curl -X GET "https://api.payabli.com/api/Query/transfersOut/your-entry-point?limitRecord=20&fromRecord=0" \
  -H "requestToken: YOUR_API_TOKEN"
```

The response includes transfer records with the gross amount, each deduction, and the net amount moved.

```json highlight=20
{
  "Summary": {
    "totalPages": 1,
    "totalRecords": 8,
    "pageSize": 20
  },
  "Records": [
    {
      "transferId": 4521,
      "paypointId": 892,
      "batchNumber": "892-20250115-SOLIDROCK",
      "batchId": 239,
      "transferDate": "2025-01-16T14:30:00Z",
      "processor": "BK",
      "grossAmount": 2847.50,
      "returnedAmount": 0.00,
      "holdAmount": 0.00,
      "billingFeesAmount": 12.50,
      "adjustmentsAmount": 0.00,
      "netTransferAmount": 2835.00
    }
  ]
}
```

See [List transfers out for paypoint](/developers/api-reference/query/get-list-of-transfers-out-for-entrypoint) for the full API reference.

/// What's next

You've retrieved payout batches and outbound transfers for a paypoint. To audit individual payouts end to end, see [Audit payout transactions with the API](/guides/pay-out-developer-payouts-audit). For more on how batches are funded and processed, see [Batches and funding](/guides/pay-out-schemas-overview#batches-and-funding).