***

title: Cookbooks and recipes home
subtitle: Use these quick tutorials to integrate Payabli workflows fast
description: Browse quickstart recipes and cookbooks organized by product area to integrate Payabli for accepting payments, making payouts, and managing your operations
og:description: Browse quickstart recipes and cookbooks organized by product area to integrate Payabli for accepting payments, making payouts, and managing your operations
keywords: embedded payments, cookbooks, recipes, payment tutorials, API quickstart, Pay In, Pay Out, Pay Ops, integration guides
slug: cookbooks/cookbooks-overview
icon: hat-chef
layout: guide
---------------------

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

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

This page contains recipes that are designed to help you use and integrate Payabli. Recipes are short tutorials that cover a workflow.
We've organized these by Payabli product area.

<Note>
  This page is under construction, we're working hard to bring you more recipes
  and cookbooks. Stay tuned!
</Note>

## General recipes

<div class="sr-only">
  <h3>Recipe: Authentication guide</h3>
  /// Step 1: Get your API token

  Navigate to **PartnerHub > Developers > API Tokens** and create a new organization token. Your API tokens carry privileges, so keep them secure!

  Your token will look something like this:
  `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...`

  /// Step 2: Add token to request headers

  Send the API token in the request header with the key `requestToken`. All API requests must be made over HTTPS.

  ```bash highlight=3
  curl -X POST "https://api.payabli.com/api/ExampleEndpoint/authorize" \
    -H "Content-Type: application/json" \
    -H "requestToken: YOUR_API_TOKEN"
  ```

  /// Step 3: Add idempotency key (recommended)

  Include a unique `idempotencyKey` header to prevent duplicate transactions. This key persists for 2 minutes.

  ```bash highlight=4
  curl -X POST "https://api.payabli.com/api/ExampleEndpoint/authorize" \
    -H "Content-Type: application/json" \
    -H "requestToken: YOUR_API_TOKEN" \
    -H "idempotencyKey: unique-request-id-123"
  ```

  Learn more about authentication, API tokens, and idempotency in [API overview](/developers/api-reference/api-overview).
</div>

## Pay In recipes

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

<div class="sr-only">
  <h3>Recipe: Run your first sale transaction</h3>
  /// Overview

  This end-to-end workflow walks through how to run a card sale transaction using the API. The `getpaid` endpoint authorizes and captures the transaction in one step, so it's immediately captured for settlement. This recipe uses the [v2 transaction API](/developers/api-reference/moneyIn/v2), which all new integrations should use.

  /// Prerequisites

  Before you start, make sure you have the following:

  * Your paypoint's `entryPoint` value
  * A `customerId` for the customer making the payment. If you don't have one, [create a customer](/cookbooks/cookbooks-overview?recipe=Create%20a%20customer) first.
  * The customer's payment details: for a card transaction, this includes the card number, expiration date, CVV, and billing ZIP code

  **PCI compliance note:** This recipe passes raw card data directly through the API for demonstration purposes. In production, use an [embedded component](/guides/pay-in-components-overview) to collect card details, or use a stored payment method, which keeps your PCI scope minimal. If you handle raw card data directly, your PCI scope is expanded and you must secure cardholder data and customer IP addresses.

  /// Step 1: Run the sale transaction

  Send a POST request to `/api/v2/MoneyIn/getpaid` with the payment method, amount, and customer information. This authorizes and captures the transaction in one step.

  ```bash
  curl -X POST "https://api.payabli.com/api/v2/MoneyIn/getpaid" \
    -H "Content-Type: application/json" \
    -H "requestToken: YOUR_API_TOKEN" \
    -d '{
      "entryPoint": "your-entry-point",
      "paymentMethod": {
        "method": "card",
        "cardHolder": "Jane Smith",
        "cardnumber": "4111111111111111",
        "cardexp": "02/27",
        "cardcvv": "999",
        "cardzip": "12345",
        "initiator": "payor"
      },
      "paymentDetails": {
        "totalAmount": 100.00,
        "serviceFee": 0
      },
      "customerData": {
        "customerId": 4440
      },
      "ipaddress": "255.255.255.255"
    }'
  ```

  A successful response returns code `A0000` (Approved) and a `paymentTransId` in the `data` object that you can use to look up the transaction later.

  ```json highlight=2,7
  {
    "code": "A0000",
    "reason": "Approved",
    "explanation": "Transaction approved",
    "action": "No action required",
    "data": {
      "paymentTransId": "3040-96dfa9a7c4ed4f82a3dd4a4a12ad28ae",
      "method": "card",
      "transStatus": 1,
      "totalAmount": 100,
      "netAmount": 100,
      "payorId": 4440
    },
    "token": null
  }
  ```

  See [Make a transaction (v2)](/developers/api-reference/moneyinV2/make-a-transaction) for the full API reference.

  /// Step 2: Check the transaction status

  Use the `paymentTransId` from the previous step to check the transaction's status and details.

  Send a GET request to `/api/MoneyIn/details/{paymentTransId}`.

  ```bash
  curl -X GET "https://api.payabli.com/api/MoneyIn/details/3040-96dfa9a7c4ed4f82a3dd4a4a12ad28ae" \
    -H "requestToken: YOUR_API_TOKEN"
  ```

  Since the `getpaid` endpoint authorizes and captures in one step, the `transStatus` is Captured (1). To track settlement progress, watch the `settlementStatus` field as it moves from Pending (0) through In Transit (1), Transferred (2), and Funded (3). See the [Pay In lifecycle](/guides/pay-in-transactions-lifecycle-overview) for more.

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

  /// What's next

  Congratulations! You just ran your first sale transaction. Next, learn about the [Pay In transaction lifecycle](/guides/pay-in-transactions-lifecycle-overview) and explore [running transactions with other payment methods](/guides/pay-in-developer-transactions-create).

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

  Create a customer record in Payabli to track payers, store payment methods, and manage subscriptions. Customer records require at least one identifier field.

  /// Prerequisites

  Before you start, make sure you have the following:

  * Your paypoint's `entrypoint` value
  * At least one customer identifier: `firstname` and `lastname`, `email`, or a custom identifier

  Check your identifier settings in **Settings > Custom Fields** in PartnerHub. See [custom identifiers](/guides/pay-ops-developer-customers-manage#custom-identifiers) for more.

  /// Create the customer

  Send a POST request to `/api/Customer/single/{entry}` with the customer's details. Include identifier fields so Payabli can match against existing records.

  ```bash
  curl -X POST "https://api.payabli.com/api/Customer/single/your-entry-point" \
    -H "Content-Type: application/json" \
    -H "requestToken: YOUR_API_TOKEN" \
    -d '{
      "customerNumber": "12356ACB",
      "firstname": "Irene",
      "lastname": "Canizales",
      "address1": "123 Bishops Trail",
      "city": "Mountain City",
      "state": "TN",
      "zip": "37612",
      "country": "US",
      "email": "irene@canizalesconcrete.com",
      "identifierFields": ["email"],
      "timeZone": -5
    }'
  ```

  The response includes a `customerId` that you can use with other endpoints to manage the customer and run transactions.

  ```json highlight=4
  {
    "isSuccess": true,
    "responseData": {
      "customerId": 17264,
      "customerNumber": "12356ACB",
      "customerStatus": 0,
      "Firstname": "Irene",
      "Lastname": "Canizales",
      "Email": "irene@canizalesconcrete.com"
    },
    "responseText": "Success"
  }
  ```

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

  /// What's next

  Congratulations! You've created a customer record. Learn more about [managing customers with the API](/guides/pay-ops-developer-customers-manage) and [customer entities in Payabli](/guides/platform-entities-overview).

  <h3>Recipe: Refund a transaction</h3>
  /// Overview

  Refund a settled Pay In transaction to return funds to the customer. You can refund the full amount or a partial amount. This recipe uses the [v2 API](/guides/pay-in-developer-transactions-cancel#v1-and-v2-endpoints).

  /// Prerequisites

  Before you start, make sure you have the following:

  * The `referenceId` of a settled transaction (also called the `transId`)
  * The refund amount, if you're issuing a partial refund

  If the transaction hasn't settled yet, [void it](/developers/api-reference/moneyinV2/void-a-transaction) instead.

  /// Refund the transaction

  For a full refund, send a POST request to `/api/v2/MoneyIn/refund/{transId}`. For a partial refund, append the amount: `/api/v2/MoneyIn/refund/{transId}/{amount}`. The refund amount excludes any service fee charged on the original transaction.

  This example refunds the full transaction amount:

  ```bash
  curl -X POST "https://api.payabli.com/api/v2/MoneyIn/refund/10-3ffa27df-b171-44e0-b251-e95fbfc7a723" \
    -H "Content-Type: application/json" \
    -H "requestToken: YOUR_API_TOKEN"
  ```

  A successful refund returns a `code` of `A0004` with a `reason` of "Refunded". The `data` object contains the full transaction details.

  ```json
  {
    "code": "A0004",
    "reason": "Refunded",
    "explanation": "Transaction refunded",
    "action": "No action required",
    "data": {
      "paymentTransId": "3040-96dfa9a7c4ed4f82a3dd4a4a12ad28ae",
      "method": "card",
      "paymentData": {
        "maskedAccount": "4XXXXXXXXXXX5439",
        "accountType": "visa",
        "holderName": "John Cassian"
      }
    },
    "token": null
  }
  ```

  To refund a partial amount, include the amount in the path. This example refunds \$100.99:

  ```bash
  curl -X POST "https://api.payabli.com/api/v2/MoneyIn/refund/10-3ffa27df-b171-44e0-b251-e95fbfc7a723/100.99" \
    -H "Content-Type: application/json" \
    -H "requestToken: YOUR_API_TOKEN"
  ```

  See [Refund a settled transaction (v2)](/developers/api-reference/moneyinV2/refund-a-settled-transaction) for the full API reference.

  /// What's next

  Congratulations! You've refunded a Pay In transaction. Learn about [choosing between void and refund](/guides/pay-in-transactions-void-vs-refund-decision) and the [Enhanced Refund Flow](/guides/pay-in-refunds-enhanced-flow-overview).

  <h3>Recipe: Void a transaction</h3>
  /// Overview

  Void an unsettled Pay In transaction to cancel it before the batch closes. Voids cancel the full transaction amount — partial voids aren't supported. This recipe uses the [v2 API](/guides/pay-in-developer-transactions-cancel#v1-and-v2-endpoints).

  /// Prerequisites

  Before you start, make sure you have the following:

  * The `referenceId` of an unsettled transaction (also called the `transId`)

  If the transaction has already settled, [refund it](/developers/api-reference/moneyinV2/refund-a-settled-transaction) instead.

  /// Void the transaction

  Send a POST request to `/api/v2/MoneyIn/void/{transId}`.

  ```bash
  curl -X POST "https://api.payabli.com/api/v2/MoneyIn/void/10-3ffa27df-b171-44e0-b251-e95fbfc7a723" \
    -H "Content-Type: application/json" \
    -H "requestToken: YOUR_API_TOKEN"
  ```

  A successful void returns a `code` of `A0003` with a `reason` of "Canceled". The `data` object contains the full transaction details.

  ```json
  {
    "code": "A0003",
    "reason": "Canceled",
    "explanation": "Transaction canceled",
    "action": "No action required",
    "data": {
      "paymentTransId": "3040-96dfa9a7c4ed4f82a3dd4a4a12ad28ae",
      "method": "card",
      "paymentData": {
        "maskedAccount": "4XXXXXXXXXXX5439",
        "accountType": "visa",
        "holderName": "John Cassian"
      }
    },
    "token": null
  }
  ```

  If you try to void a transaction that has already been settled or voided, the API returns a 400 status.

  See [Void a transaction (v2)](/developers/api-reference/moneyinV2/void-a-transaction) for the full API reference.

  /// What's next

  Congratulations! You've voided a Pay In transaction. Learn about [choosing between void and refund](/guides/pay-in-transactions-void-vs-refund-decision) and explore [other cancellation methods](/guides/pay-in-developer-transactions-cancel).

  <h3>Recipe: Charge a saved payment method</h3>
  /// Overview

  Charge a returning customer using a payment method you've already tokenized and stored, without collecting their card or bank account details again. This recipe uses the [v2 transaction API](/developers/api-reference/moneyIn/v2), which all new integrations should use.

  /// Prerequisites

  Before you start, make sure you have the following:

  * A `storedMethodId` for the customer's saved payment method. If you haven't saved one yet, see [Save a payment method](/guides/platform-developer-tokenization-save-method).
  * The `customerId` for the customer who owns the stored method
  * Your paypoint's `entryPoint` value
  * Know whether the stored method is a `card` or `ach` method, so you can set the `method` field correctly

  /// Step 1: Run the transaction

  Send a POST request to `/api/v2/MoneyIn/getpaid` with the `storedMethodId` in the `paymentMethod` object instead of raw card or bank account details.

  Set `initiator` to `payor` for customer-initiated transactions, or `merchant` for merchant-initiated transactions. See [CIT and MIT overview](/guides/pay-in-transactions-cit-mit-overview) for guidance on which to use.

  ```bash highlight=8-9
  curl -X POST "https://api.payabli.com/api/v2/MoneyIn/getpaid" \
    -H "Content-Type: application/json" \
    -H "requestToken: YOUR_API_TOKEN" \
    -d '{
      "entryPoint": "your-entry-point",
      "paymentMethod": {
        "method": "card",
        "storedMethodId": "1ec55af9-7b5a-4ff0-81ed-c12d2f95e135-4440",
        "initiator": "payor",
        "storedMethodUsageType": "unscheduled"
      },
      "paymentDetails": {
        "totalAmount": 100.00,
        "serviceFee": 0
      },
      "customerData": {
        "customerId": 4440
      }
    }'
  ```

  A successful response returns code `A0000` (Approved) and a `paymentTransId` in the `data` object that you can use to look up the transaction later.

  ```json highlight=2,7
  {
    "code": "A0000",
    "reason": "Approved",
    "explanation": "Transaction approved",
    "action": "No action required",
    "data": {
      "paymentTransId": "3040-9708542b00354726ad8a6b0c65bc7a54",
      "method": "card",
      "transStatus": 1,
      "totalAmount": 100,
      "netAmount": 100,
      "payorId": 4440
    },
    "token": null
  }
  ```

  See [Make a transaction (v2)](/developers/api-reference/moneyinV2/make-a-transaction) for the full API reference.

  /// Step 2: Check the transaction status

  Use the `paymentTransId` from the previous step to check the transaction's status and details.

  Send a GET request to `/api/MoneyIn/details/{paymentTransId}`.

  ```bash
  curl -X GET "https://api.payabli.com/api/MoneyIn/details/3040-9708542b00354726ad8a6b0c65bc7a54" \
    -H "requestToken: YOUR_API_TOKEN"
  ```

  Since the `getpaid` endpoint authorizes and captures in one step, the `transStatus` is Captured (1). To track settlement progress, watch the `settlementStatus` field as it moves from Pending (0) through In Transit (1), Transferred (2), and Funded (3). See [Pay In lifecycle](/guides/pay-in-transactions-lifecycle-overview) for more.

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

  /// What's next

  Congratulations! You just charged a saved payment method. Next, learn about [tokenization](/guides/platform-tokenization-overview) and explore other ways to [make transactions](/guides/pay-in-developer-transactions-create).

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

  Generate a payment link from an existing invoice and send it to a customer via email. Payment links direct customers to a hosted payment page where they can pay using your accepted methods.

  /// Prerequisites

  Before you start, make sure you have the following:

  * An `idInvoice` for an invoice created via the API. If you haven't created one yet, see [Manage invoices](/guides/pay-in-developer-invoices-manage).
  * Your paypoint's `entryPoint` value
  * The customer's email address

  /// Step 1: Generate the payment link

  Create a payment link from your invoice. You can customize the hosted payment page's branding, accepted payment methods, and layout.

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

  ```bash
  curl -X POST "https://api.payabli.com/api/PaymentLink/23548884" \
    -H "Content-Type: application/json" \
    -H "requestToken: YOUR_API_TOKEN" \
    -d '{
      "page": {
        "enabled": true,
        "header": "Payment Page",
        "description": "Complete your payment securely",
        "order": 0
      },
      "paymentButton": {
        "enabled": true,
        "label": "Pay Now",
        "order": 0
      },
      "paymentMethods": {
        "enabled": true,
        "header": "Payment Methods",
        "allMethodsChecked": true,
        "methods": {
          "visa": true,
          "mastercard": true,
          "amex": true,
          "discover": true,
          "eCheck": true
        },
        "order": 0
      },
      "payor": {
        "enabled": true,
        "header": "Payor Information",
        "order": 0,
        "fields": [
          {
            "name": "fullName",
            "label": "Full Name",
            "required": true,
            "display": true,
            "order": 0,
            "validation": "alpha",
            "identifier": true,
            "fixed": true,
            "value": "",
            "width": 0
          }
        ]
      }
    }'
  ```

  The response includes the payment link ID in `responseData`. You need this ID to send the link in the next step.

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

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

  /// Step 2: Send the payment link

  Send the payment link to the customer via email. You can include additional recipients and attach a PDF invoice.

  Send a POST request to `/api/PaymentLink/push/{payLinkId}`.

  ```bash
  curl -X POST "https://api.payabli.com/api/PaymentLink/push/2325-XXXXXXX-90b1-4598-b6c7-44cdcbf495d7-1234" \
    -H "Content-Type: application/json" \
    -H "requestToken: YOUR_API_TOKEN" \
    -d '{
      "channel": "email",
      "attachFile": true,
      "additionalEmails": [
        "admin@example.com",
        "accounting@example.com"
      ]
    }'
  ```

  A successful response returns the `payLinkId` and a success message.

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

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

  /// What's next

  Congratulations! You just sent a payment link to your customer. Next, learn about [choosing an invoice delivery strategy](/guides/pay-in-invoicing-delivery-decision) and explore all the ways to [manage payment links](/guides/pay-in-developer-payment-links-manage).

  <h3>Recipe: Create and send an invoice</h3>
  /// Overview

  Create a one-time invoice for a customer and send it via email with an attached PDF. This recipe covers the two-call workflow: create the invoice, then send it.

  /// Prerequisites

  Before you start, make sure you have the following:

  * Your paypoint's `entryPoint` value
  * A `customerId` for an existing customer. If you haven't created one yet, see [Manage customers](/guides/pay-ops-developer-customers-manage).
  * Invoice details: line items, amounts, and a unique invoice number

  /// Step 1: Create the invoice

  Create the invoice linked to an existing customer. The request includes customer identification, line items, amount, and invoice metadata.

  Send a POST request to `/api/Invoice/{entry}`.

  ```bash
  curl -X POST "https://api.payabli.com/api/Invoice/your-entry-point" \
    -H "Content-Type: application/json" \
    -H "requestToken: YOUR_API_TOKEN" \
    -d '{
      "customerData": {
        "customerId": 4440,
        "firstName": "Tamara",
        "lastName": "Bagratoni"
      },
      "invoiceData": {
        "invoiceNumber": "INV-3",
        "invoiceDate": "2025-10-19",
        "invoiceAmount": 982.37,
        "invoiceType": 0,
        "invoiceStatus": 1,
        "frequency": "onetime",
        "discount": 10,
        "items": [
          {
            "itemProductName": "Adventure Consult",
            "itemDescription": "Consultation for Georgian tours",
            "itemCost": 100,
            "itemQty": 1
          },
          {
            "itemProductName": "Deposit",
            "itemDescription": "Deposit for trip planning",
            "itemCost": 882.37,
            "itemQty": 1
          }
        ]
      }
    }'
  ```

  The response includes the invoice ID in `responseData`. You need this to send the invoice in the next step.

  ```json highlight=3
  {
    "isSuccess": true,
    "responseData": 3625,
    "responseText": "Success"
  }
  ```

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

  /// Step 2: Send the invoice

  Email the invoice to the customer. Use `attachfile=true` to include a PDF copy, and `mail2` to specify the recipient email address. If you omit `mail2`, Payabli sends the invoice to the email address on file for the customer.

  Send a GET request to `/api/Invoice/send/{idInvoice}`.

  ```bash
  curl -X GET "https://api.payabli.com/api/Invoice/send/3625?attachfile=true&mail2=tamara@example.com" \
    -H "requestToken: YOUR_API_TOKEN"
  ```

  ```json
  {
    "isSuccess": true,
    "responseText": "Success"
  }
  ```

  See [Send invoice via email](/developers/api-reference/invoice/send-invoice-via-email) for the full API reference.

  /// What's next

  Congratulations! You just created and sent an invoice. Next, explore the full invoice lifecycle in [Manage invoices with the API](/guides/pay-in-developer-invoices-manage) and learn how to [choose an invoice delivery strategy](/guides/pay-in-invoicing-delivery-decision).

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

  Retrieve a list of batches and transfers for a paypoint to monitor settlement activity. A **batch** is a group of transactions that are settled together at the end of a processing cycle. A **transfer** is the actual movement of funds from the batch into the paypoint's bank account.

  /// 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 batches for the paypoint

  Query the batches endpoint to retrieve settlement batches for a paypoint. Each batch groups transactions and, once transferred, includes a `Transfer` object with deposit details.

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

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

  The response includes batch records. If a batch has been transferred, the `Transfer` object contains the transfer details. If `Transfer` is `null`, the batch hasn't been transferred yet.

  ```json highlight=20-28
  {
    "Summary": {
      "totalRecords": 2,
      "totalAmount": 1299.46,
      "totalPages": 1,
      "pageSize": 20
    },
    "Records": [
      {
        "IdBatch": 1012,
        "BatchNumber": "BT-2023041421-187",
        "BatchDate": "2023-04-14T21:01:03Z",
        "BatchAmount": 1080.44,
        "BatchStatus": 2,
        "BatchRecords": 4,
        "PaypointId": 187,
        "PaypointDba": "Gruzya Adventure Outfitters",
        "Method": "card",
        "ExpectedDepositDate": "2023-04-15T00:00:00Z",
        "Transfer": {
          "TransferId": 5998,
          "TransferDate": "2023-04-16T00:00:00Z",
          "TransferStatus": 1,
          "GrossAmount": 1080.44,
          "ChargeBackAmount": 0,
          "ReturnedAmount": 0,
          "NetFundedAmount": 1080.44
        }
      }
    ]
  }
  ```

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

  /// Step 2: Get transfers for the paypoint

  Query the transfers endpoint to get deposit records with adjustment details like chargebacks, ACH returns, and fees.

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

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

  The response includes transfer records with gross amounts, deductions, and the net amount deposited.

  ```json
  {
    "Summary": {
      "totalPages": 1,
      "totalRecords": 1,
      "pageSize": 20
    },
    "Records": [
      {
        "transferId": 79851,
        "paypointId": 705,
        "batchNumber": "split_705_gp_11-16-2024",
        "batchId": 111430,
        "transferDate": "2024-11-17T08:20:07.288+00:00",
        "transferStatus": 2,
        "grossAmount": 1029.00,
        "chargeBackAmount": 25.00,
        "returnedAmount": 0.00,
        "holdAmount": 0.00,
        "billingFeesAmount": 0.00,
        "adjustmentsAmount": 0.00,
        "netTransferAmount": 1004.00
      }
    ]
  }
  ```

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

  /// What's next

  You've retrieved batches and transfers for a paypoint. To track chargebacks and ACH returns within transfers, see [Reconcile adjustments in transfers](/guides/pay-ops-developer-transfers-reconcile). For more on how batches and transfers relate, see [How money moves](/guides/platform-how-money-moves-overview#transfers).

  <h3>Recipe: Set up autopay on an invoice</h3>
  /// Overview

  Set up recurring automatic payments on an invoice by creating a subscription that references it. In this example, a customer owes $1,800 and pays it off at $150 per month over 12 months. Each subscription payment automatically posts against the invoice.

  /// Prerequisites

  Before you start, make sure you have the following:

  * Your paypoint's `entryPoint` value
  * A `customerId` for an existing customer. If you haven't created one yet, see [Manage customers](/guides/pay-ops-developer-customers-manage).
  * Invoice details: line items, amounts, and a unique invoice number
  * A `storedMethodId` for the customer's saved payment method. To save a method, see [Save a payment method](/guides/platform-developer-tokenization-save-method).
  * A schedule for the autopay: start date, end date (or open-ended), and frequency

  /// Step 1: Create the invoice

  Create a one-time invoice for the customer. This is the invoice that subscription payments will post against.

  Send a POST request to `/api/Invoice/{entry}`.

  ```bash
  curl -X POST "https://api.payabli.com/api/Invoice/your-entry-point" \
    -H "Content-Type: application/json" \
    -H "requestToken: YOUR_API_TOKEN" \
    -d '{
      "customerData": {
        "customerId": 4440
      },
      "invoiceData": {
        "invoiceNumber": "INV-2345",
        "invoiceDate": "2026-04-01",
        "invoiceDueDate": "2026-04-15",
        "invoiceAmount": 1800.00,
        "invoiceType": 0,
        "invoiceStatus": 1,
        "frequency": "onetime",
        "items": [
          {
            "itemProductName": "Annual service agreement",
            "itemDescription": "Service agreement, 12-month term",
            "itemCost": 1800.00,
            "itemQty": 1
          }
        ]
      }
    }'
  ```

  In the next step, you use the same `invoiceNumber` to link the subscription to this invoice.

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

  /// Step 2: Create a subscription with the invoice

  Create a subscription that charges $150 per month against the $1,800 invoice from step 1. The `invoiceNumber` in the subscription request must match the one you set when creating the invoice — this is what ties the payments to the invoice. The `scheduleDetails.frequency` controls when payments run, while `invoiceData.frequency` describes the invoice itself — keep the invoice as `"onetime"` and let the subscription handle the recurrence.

  Send a POST request to `/api/Subscription/add`.

  ```bash
  curl -X POST "https://api.payabli.com/api/Subscription/add" \
    -H "Content-Type: application/json" \
    -H "requestToken: YOUR_API_TOKEN" \
    -d '{
      "entryPoint": "your-entry-point",
      "customerData": {
        "customerId": 4440
      },
      "paymentMethod": {
        "method": "card",
        "storedMethodId": "1a2b3c4d-5e6f-7890-abcd-ef12345678901",
        "initiator": "merchant",
        "storedMethodUsageType": "recurring"
      },
      "paymentDetails": {
        "totalAmount": 150.00,
        "serviceFee": 0
      },
      "scheduleDetails": {
        "startDate": "04-15-2026",
        "endDate": "04-15-2027",
        "frequency": "monthly"
      },
      "invoiceData": {
        "invoiceNumber": "INV-2345",
        "invoiceAmount": 150.00,
        "frequency": "onetime"
      }
    }'
  ```

  The response includes the subscription ID in `responseData` and the linked `customerId`.

  ```json highlight=3
  {
    "responseText": "Success",
    "isSuccess": true,
    "responseData": 396,
    "customerId": 4440
  }
  ```

  See [Create subscription](/developers/api-reference/subscription/create-a-subscription-or-scheduled-payment) for the full API reference.

  /// What's next

  Congratulations! You just set up autopay on an invoice. Next, learn how to [manage and update subscriptions](/guides/pay-in-developer-subscriptions-manage) and explore the full invoice lifecycle in [Manage invoices with the API](/guides/pay-in-developer-invoices-manage).
</div>

## Pay Out recipes

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

<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: 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>

## Pay Ops recipes

Coming soon!