# Pay Out cookbook

> 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

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

<AudienceInfo audiences={["developers", "partners", "merchants"]} />

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.

<div class="sr-only">
  <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: 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).
</div>