> 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

# Send instant payouts

> Use wire transfer and Real-Time Payments (RTP) rails to send irrevocable, same-day payouts to US vendors

Payabli supports wire transfer and Real-Time Payments (RTP) as instant payout rails for fast vendor disbursements. Both use the same [authorize-and-capture flow](/guides/pay-out-developer-payouts-manage) as ACH and check payouts, with a different `method` value in the request.

## Considerations

Keep these considerations in mind when working with instant payouts:

* **Irrevocable.** Wire and RTP payouts can't be cancelled or reissued after capture. Unlike ACH, there's no window to reverse the transaction.
* **US domestic only.** Instant payouts are available for US vendors only. Canadian vendors aren't supported for wire or RTP.
* **Balance required.** The paypoint must have enough available payout balance to cover the transaction. Instant payouts that exceed the available balance are rejected with an `Insufficient Funds` error.
* **Same statuses, faster transitions.** Instant payouts use the same status flow as ACH (`authorized` → `captured` → `funded` → `paid`), but transitions happen in rapid succession after capture.

## Wire vs RTP

Both rails are much faster than ACH, but they differ in timing and availability.

|                     | Wire transfer                                             | RTP                                                       |
| ------------------- | --------------------------------------------------------- | --------------------------------------------------------- |
| **Method value**    | `"wire"`                                                  | `"rtp"`                                                   |
| **Speed**           | Same-day (during business hours)                          | Near-real-time (seconds)                                  |
| **Availability**    | Business days only                                        | Any time, every day, all year                             |
| **Cancellable**     | No                                                        | No                                                        |
| **Able to reissue** | No                                                        | No                                                        |
| **Required fields** | `achHolder`, `achRouting`, `achAccount`, `achAccountType` | `achHolder`, `achRouting`, `achAccount`, `achAccountType` |

## Authorize an instant payout

Send a POST request to `/api/MoneyOut/authorize` with `method` set to `"wire"` or `"rtp"` in the `paymentMethod` object. See the [API reference](/developers/api-reference/moneyout/authorize-a-transaction-for-payout) for full documentation.

The required bank detail fields are the same as ACH: `achHolder`, `achRouting`, `achAccount`, and `achAccountType`.

### Request

POST [https://api-sandbox.payabli.com/api/MoneyOut/authorize](https://api-sandbox.payabli.com/api/MoneyOut/authorize)

```curl WirePayout
curl -X POST https://api-sandbox.payabli.com/api/MoneyOut/authorize \
     -H "requestToken: <apiKey>" \
     -H "Content-Type: application/json" \
     -d '{
  "entryPoint": "48acde49",
  "paymentMethod": {
    "method": "wire",
    "achHolder": "Jane Smith",
    "achRouting": "011401533",
    "achAccount": "987654321",
    "achAccountType": "checking"
  },
  "paymentDetails": {
    "totalAmount": 2500
  },
  "vendorData": {
    "vendorNumber": "7895433"
  },
  "invoiceData": [
    {
      "billId": 54323
    }
  ],
  "orderDescription": "Contractor Payment"
}'
```

```typescript WirePayout
import { PayabliClient } from "@payabli/sdk-node";

async function main() {
    const client = new PayabliClient({
        apiKey: "YOUR_API_KEY_HERE",
    });
    await client.moneyOut.authorizeOut({
        entryPoint: "48acde49",
        paymentMethod: {
            method: "wire",
            achHolder: "Jane Smith",
            achRouting: "011401533",
            achAccount: "987654321",
            achAccountType: "checking",
        },
        paymentDetails: {
            totalAmount: 2500,
        },
        vendorData: {
            vendorNumber: "7895433",
        },
        invoiceData: [
            {
                billId: 54323,
            },
        ],
        orderDescription: "Contractor Payment",
    });
}
main();

```

```python WirePayout
from payabli import payabli, AuthorizePaymentMethod, RequestOutAuthorizePaymentDetails, RequestOutAuthorizeVendorData, RequestOutAuthorizeInvoiceData

client = payabli(
    api_key="YOUR_API_KEY_HERE",
)

client.money_out.authorize_out(
    entry_point="48acde49",
    payment_method=AuthorizePaymentMethod(
        method="wire",
        ach_holder="Jane Smith",
        ach_routing="011401533",
        ach_account="987654321",
        ach_account_type="checking",
    ),
    payment_details=RequestOutAuthorizePaymentDetails(
        total_amount=2500,
    ),
    vendor_data=RequestOutAuthorizeVendorData(
        vendor_number="7895433",
    ),
    invoice_data=[
        RequestOutAuthorizeInvoiceData(
            bill_id=54323,
        )
    ],
    order_description="Contractor Payment",
)

```

```java WirePayout
package com.example.usage;

import io.github.payabli.api.PayabliPayabliApiOasClient;
import io.github.payabli.api.resources.moneyout.requests.RequestOutAuthorize;
import io.github.payabli.api.types.AuthorizePaymentMethod;
import io.github.payabli.api.types.RequestOutAuthorizeInvoiceData;
import io.github.payabli.api.types.RequestOutAuthorizePaymentDetails;
import io.github.payabli.api.types.RequestOutAuthorizeVendorData;
import java.util.Arrays;

public class Example {
    public static void main(String[] args) {
        PayabliPayabliApiOasClient client = PayabliPayabliApiOasClient
            .builder()
            .apiKey("YOUR_API_KEY_HERE")
            .build();

        client.moneyOut().authorizeOut(
            RequestOutAuthorize
                .builder()
                .entryPoint("48acde49")
                .paymentMethod(
                    AuthorizePaymentMethod
                        .builder()
                        .method("wire")
                        .achHolder("Jane Smith")
                        .achRouting("011401533")
                        .achAccount("987654321")
                        .achAccountType("checking")
                        .build()
                )
                .paymentDetails(
                    RequestOutAuthorizePaymentDetails
                        .builder()
                        .totalAmount(2500.0)
                        .build()
                )
                .vendorData(
                    RequestOutAuthorizeVendorData
                        .builder()
                        .vendorNumber("7895433")
                        .build()
                )
                .invoiceData(
                    Arrays.asList(
                        RequestOutAuthorizeInvoiceData
                            .builder()
                            .billId(54323L)
                            .build()
                    )
                )
                .orderDescription("Contractor Payment")
                .build()
        );
    }
}
```

```ruby WirePayout
require "payabli"

client = Payabli::Client.new(api_key: "YOUR_API_KEY_HERE")

client.money_out.authorize_out(
  entry_point: "48acde49",
  payment_method: {
    method_: "wire",
    ach_holder: "Jane Smith",
    ach_routing: "011401533",
    ach_account: "987654321",
    ach_account_type: "checking"
  },
  payment_details: {
    total_amount: 2500
  },
  vendor_data: {
    vendor_number: "7895433"
  },
  invoice_data: [{
    bill_id: 54323
  }],
  order_description: "Contractor Payment"
)

```

```csharp WirePayout
using PayabliPayabliApiOas;
using System.Threading.Tasks;
using System.Collections.Generic;

namespace Usage;

public class Example
{
    public async Task Do() {
        var client = new PayabliPayabliApiOasClient(
            apiKey: "YOUR_API_KEY_HERE"
        );

        await client.MoneyOut.AuthorizeOutAsync(
            new RequestOutAuthorize {
                EntryPoint = "48acde49",
                PaymentMethod = new AuthorizePaymentMethod {
                    Method = "wire",
                    AchHolder = "Jane Smith",
                    AchRouting = "011401533",
                    AchAccount = "987654321",
                    AchAccountType = "checking"
                },
                PaymentDetails = new RequestOutAuthorizePaymentDetails {
                    TotalAmount = 2500
                },
                VendorData = new RequestOutAuthorizeVendorData {
                    VendorNumber = "7895433"
                },
                InvoiceData = new List<RequestOutAuthorizeInvoiceData>(){
                    new RequestOutAuthorizeInvoiceData {
                        BillId = 54323L
                    },
                }
                ,
                OrderDescription = "Contractor Payment"
            }
        );
    }

}

```

```go WirePayout
package example

import (
    context "context"

    payabli "github.com/payabli/sdk-go"
    client "github.com/payabli/sdk-go/client"
    option "github.com/payabli/sdk-go/option"
)

func do() {
    client := client.NewClient(
        option.WithApiKey(
            "YOUR_API_KEY_HERE",
        ),
    )
    request := &payabli.RequestOutAuthorize{
        EntryPoint: "48acde49",
        PaymentMethod: &payabli.AuthorizePaymentMethod{
            Method: "wire",
            AchHolder: payabli.String(
                "Jane Smith",
            ),
            AchRouting: payabli.String(
                "011401533",
            ),
            AchAccount: payabli.String(
                "987654321",
            ),
            AchAccountType: payabli.String(
                "checking",
            ),
        },
        PaymentDetails: &payabli.RequestOutAuthorizePaymentDetails{
            TotalAmount: payabli.Float64(
                2500,
            ),
        },
        VendorData: &payabli.RequestOutAuthorizeVendorData{
            VendorNumber: payabli.String(
                "7895433",
            ),
        },
        InvoiceData: []*payabli.RequestOutAuthorizeInvoiceData{
            &payabli.RequestOutAuthorizeInvoiceData{
                BillId: payabli.Int64(
                    int64(54323),
                ),
            },
        },
        OrderDescription: payabli.String(
            "Contractor Payment",
        ),
    }
    client.MoneyOut.AuthorizeOut(
        context.TODO(),
        request,
    )
}

```

```php WirePayout
<?php

namespace Example;

use Payabli\PayabliClient;
use Payabli\MoneyOut\Requests\RequestOutAuthorize;
use Payabli\Types\AuthorizePaymentMethod;
use Payabli\Types\RequestOutAuthorizePaymentDetails;
use Payabli\Types\RequestOutAuthorizeVendorData;
use Payabli\Types\RequestOutAuthorizeInvoiceData;

$client = new PayabliClient(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->moneyOut->authorizeOut(
    new RequestOutAuthorize([
        'entryPoint' => '48acde49',
        'paymentMethod' => new AuthorizePaymentMethod([
            'method' => 'wire',
            'achHolder' => 'Jane Smith',
            'achRouting' => '011401533',
            'achAccount' => '987654321',
            'achAccountType' => 'checking',
        ]),
        'paymentDetails' => new RequestOutAuthorizePaymentDetails([
            'totalAmount' => 2500,
        ]),
        'vendorData' => new RequestOutAuthorizeVendorData([
            'vendorNumber' => '7895433',
        ]),
        'invoiceData' => [
            new RequestOutAuthorizeInvoiceData([
                'billId' => 54323,
            ]),
        ],
        'orderDescription' => 'Contractor Payment',
    ]),
);

```

```swift WirePayout
import Foundation

let headers = [
  "requestToken": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "entryPoint": "48acde49",
  "paymentMethod": [
    "method": "wire",
    "achHolder": "Jane Smith",
    "achRouting": "011401533",
    "achAccount": "987654321",
    "achAccountType": "checking"
  ],
  "paymentDetails": ["totalAmount": 2500],
  "vendorData": ["vendorNumber": "7895433"],
  "invoiceData": [["billId": 54323]],
  "orderDescription": "Contractor Payment"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/MoneyOut/authorize")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Request

POST [https://api-sandbox.payabli.com/api/MoneyOut/authorize](https://api-sandbox.payabli.com/api/MoneyOut/authorize)

```curl RtpPayout
curl -X POST https://api-sandbox.payabli.com/api/MoneyOut/authorize \
     -H "requestToken: <apiKey>" \
     -H "Content-Type: application/json" \
     -d '{
  "entryPoint": "48acde49",
  "paymentMethod": {
    "method": "rtp",
    "achHolder": "Jane Smith",
    "achRouting": "011401533",
    "achAccount": "987654321",
    "achAccountType": "checking"
  },
  "paymentDetails": {
    "totalAmount": 1200
  },
  "vendorData": {
    "vendorNumber": "7895433"
  },
  "invoiceData": [
    {
      "billId": 54323
    }
  ],
  "orderDescription": "Urgent Vendor Payment"
}'
```

```typescript RtpPayout
import { PayabliClient } from "@payabli/sdk-node";

async function main() {
    const client = new PayabliClient({
        apiKey: "YOUR_API_KEY_HERE",
    });
    await client.moneyOut.authorizeOut({
        entryPoint: "48acde49",
        paymentMethod: {
            method: "rtp",
            achHolder: "Jane Smith",
            achRouting: "011401533",
            achAccount: "987654321",
            achAccountType: "checking",
        },
        paymentDetails: {
            totalAmount: 1200,
        },
        vendorData: {
            vendorNumber: "7895433",
        },
        invoiceData: [
            {
                billId: 54323,
            },
        ],
        orderDescription: "Urgent Vendor Payment",
    });
}
main();

```

```python RtpPayout
from payabli import payabli, AuthorizePaymentMethod, RequestOutAuthorizePaymentDetails, RequestOutAuthorizeVendorData, RequestOutAuthorizeInvoiceData

client = payabli(
    api_key="YOUR_API_KEY_HERE",
)

client.money_out.authorize_out(
    entry_point="48acde49",
    payment_method=AuthorizePaymentMethod(
        method="rtp",
        ach_holder="Jane Smith",
        ach_routing="011401533",
        ach_account="987654321",
        ach_account_type="checking",
    ),
    payment_details=RequestOutAuthorizePaymentDetails(
        total_amount=1200,
    ),
    vendor_data=RequestOutAuthorizeVendorData(
        vendor_number="7895433",
    ),
    invoice_data=[
        RequestOutAuthorizeInvoiceData(
            bill_id=54323,
        )
    ],
    order_description="Urgent Vendor Payment",
)

```

```java RtpPayout
package com.example.usage;

import io.github.payabli.api.PayabliPayabliApiOasClient;
import io.github.payabli.api.resources.moneyout.requests.RequestOutAuthorize;
import io.github.payabli.api.types.AuthorizePaymentMethod;
import io.github.payabli.api.types.RequestOutAuthorizeInvoiceData;
import io.github.payabli.api.types.RequestOutAuthorizePaymentDetails;
import io.github.payabli.api.types.RequestOutAuthorizeVendorData;
import java.util.Arrays;

public class Example {
    public static void main(String[] args) {
        PayabliPayabliApiOasClient client = PayabliPayabliApiOasClient
            .builder()
            .apiKey("YOUR_API_KEY_HERE")
            .build();

        client.moneyOut().authorizeOut(
            RequestOutAuthorize
                .builder()
                .entryPoint("48acde49")
                .paymentMethod(
                    AuthorizePaymentMethod
                        .builder()
                        .method("rtp")
                        .achHolder("Jane Smith")
                        .achRouting("011401533")
                        .achAccount("987654321")
                        .achAccountType("checking")
                        .build()
                )
                .paymentDetails(
                    RequestOutAuthorizePaymentDetails
                        .builder()
                        .totalAmount(1200.0)
                        .build()
                )
                .vendorData(
                    RequestOutAuthorizeVendorData
                        .builder()
                        .vendorNumber("7895433")
                        .build()
                )
                .invoiceData(
                    Arrays.asList(
                        RequestOutAuthorizeInvoiceData
                            .builder()
                            .billId(54323L)
                            .build()
                    )
                )
                .orderDescription("Urgent Vendor Payment")
                .build()
        );
    }
}
```

```ruby RtpPayout
require "payabli"

client = Payabli::Client.new(api_key: "YOUR_API_KEY_HERE")

client.money_out.authorize_out(
  entry_point: "48acde49",
  payment_method: {
    method_: "rtp",
    ach_holder: "Jane Smith",
    ach_routing: "011401533",
    ach_account: "987654321",
    ach_account_type: "checking"
  },
  payment_details: {
    total_amount: 1200
  },
  vendor_data: {
    vendor_number: "7895433"
  },
  invoice_data: [{
    bill_id: 54323
  }],
  order_description: "Urgent Vendor Payment"
)

```

```csharp RtpPayout
using PayabliPayabliApiOas;
using System.Threading.Tasks;
using System.Collections.Generic;

namespace Usage;

public class Example
{
    public async Task Do() {
        var client = new PayabliPayabliApiOasClient(
            apiKey: "YOUR_API_KEY_HERE"
        );

        await client.MoneyOut.AuthorizeOutAsync(
            new RequestOutAuthorize {
                EntryPoint = "48acde49",
                PaymentMethod = new AuthorizePaymentMethod {
                    Method = "rtp",
                    AchHolder = "Jane Smith",
                    AchRouting = "011401533",
                    AchAccount = "987654321",
                    AchAccountType = "checking"
                },
                PaymentDetails = new RequestOutAuthorizePaymentDetails {
                    TotalAmount = 1200
                },
                VendorData = new RequestOutAuthorizeVendorData {
                    VendorNumber = "7895433"
                },
                InvoiceData = new List<RequestOutAuthorizeInvoiceData>(){
                    new RequestOutAuthorizeInvoiceData {
                        BillId = 54323L
                    },
                }
                ,
                OrderDescription = "Urgent Vendor Payment"
            }
        );
    }

}

```

```go RtpPayout
package example

import (
    context "context"

    payabli "github.com/payabli/sdk-go"
    client "github.com/payabli/sdk-go/client"
    option "github.com/payabli/sdk-go/option"
)

func do() {
    client := client.NewClient(
        option.WithApiKey(
            "YOUR_API_KEY_HERE",
        ),
    )
    request := &payabli.RequestOutAuthorize{
        EntryPoint: "48acde49",
        PaymentMethod: &payabli.AuthorizePaymentMethod{
            Method: "rtp",
            AchHolder: payabli.String(
                "Jane Smith",
            ),
            AchRouting: payabli.String(
                "011401533",
            ),
            AchAccount: payabli.String(
                "987654321",
            ),
            AchAccountType: payabli.String(
                "checking",
            ),
        },
        PaymentDetails: &payabli.RequestOutAuthorizePaymentDetails{
            TotalAmount: payabli.Float64(
                1200,
            ),
        },
        VendorData: &payabli.RequestOutAuthorizeVendorData{
            VendorNumber: payabli.String(
                "7895433",
            ),
        },
        InvoiceData: []*payabli.RequestOutAuthorizeInvoiceData{
            &payabli.RequestOutAuthorizeInvoiceData{
                BillId: payabli.Int64(
                    int64(54323),
                ),
            },
        },
        OrderDescription: payabli.String(
            "Urgent Vendor Payment",
        ),
    }
    client.MoneyOut.AuthorizeOut(
        context.TODO(),
        request,
    )
}

```

```php RtpPayout
<?php

namespace Example;

use Payabli\PayabliClient;
use Payabli\MoneyOut\Requests\RequestOutAuthorize;
use Payabli\Types\AuthorizePaymentMethod;
use Payabli\Types\RequestOutAuthorizePaymentDetails;
use Payabli\Types\RequestOutAuthorizeVendorData;
use Payabli\Types\RequestOutAuthorizeInvoiceData;

$client = new PayabliClient(
    apiKey: 'YOUR_API_KEY_HERE',
);
$client->moneyOut->authorizeOut(
    new RequestOutAuthorize([
        'entryPoint' => '48acde49',
        'paymentMethod' => new AuthorizePaymentMethod([
            'method' => 'rtp',
            'achHolder' => 'Jane Smith',
            'achRouting' => '011401533',
            'achAccount' => '987654321',
            'achAccountType' => 'checking',
        ]),
        'paymentDetails' => new RequestOutAuthorizePaymentDetails([
            'totalAmount' => 1200,
        ]),
        'vendorData' => new RequestOutAuthorizeVendorData([
            'vendorNumber' => '7895433',
        ]),
        'invoiceData' => [
            new RequestOutAuthorizeInvoiceData([
                'billId' => 54323,
            ]),
        ],
        'orderDescription' => 'Urgent Vendor Payment',
    ]),
);

```

```swift RtpPayout
import Foundation

let headers = [
  "requestToken": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "entryPoint": "48acde49",
  "paymentMethod": [
    "method": "rtp",
    "achHolder": "Jane Smith",
    "achRouting": "011401533",
    "achAccount": "987654321",
    "achAccountType": "checking"
  ],
  "paymentDetails": ["totalAmount": 1200],
  "vendorData": ["vendorNumber": "7895433"],
  "invoiceData": [["billId": 54323]],
  "orderDescription": "Urgent Vendor Payment"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/MoneyOut/authorize")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

A successful request returns a JSON response with a `referenceId` you'll use to capture the transaction.

### Response (200)

```json
{
  "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": 456,
    "vendorId": 456,
    "methodReferenceId": null
  }
}
```

## Capture the payout

Capture works the same as any other payout. Send a POST request to `/api/MoneyOut/capture/{referenceId}` with the `referenceId` from the authorization response.

Capturing a wire or RTP payout is irreversible. Unlike ACH payouts, you can't cancel after capture. Make sure the amount, vendor, and bank details are correct before capturing.

## Payout lifecycle

Instant payouts follow the same status progression as ACH, but with key behavioral differences:

| Status       | ACH behavior                       | Wire/RTP behavior                                          |
| ------------ | ---------------------------------- | ---------------------------------------------------------- |
| `authorized` | Payout created, awaiting capture   | Same                                                       |
| `captured`   | Added to next batch for processing | Triggers immediate funding                                 |
| `funded`     | Funded when batch processes        | Funded immediately after capture                           |
| `paid`       | Set after bank confirmation        | Set when batch closes, unless a failure signal is received |

### Batching

Wire and RTP payouts are still grouped into batches, but batching is a grouping mechanism only. It doesn't delay settlement. Instant payouts settle immediately regardless of when the batch closes.

### Cancellation

You can cancel a wire or RTP payout while it's in `authorized` status, before capture. Once captured, the payout is irrevocable. You can't cancel or reissue it.

This is different from ACH, where there's a short window after capture to cancel before processing begins.

## Balance requirements

Instant payouts require the paypoint to have enough available payout balance. Payabli validates the balance at authorize time for wire and RTP only. ACH and other rails bypass this check.

To add funds to a paypoint's available balance, use the [Deposit funds](/developers/api-reference/funding/deposit-funds) endpoint. Deposited funds enter a pending state and aren't available for instant payouts until confirmed through FBO reconciliation.

## Error handling

Instant payouts can return the same errors as other payout methods, plus two balance-specific errors. Both return HTTP `400 Bad Request` with error code `3729`:

| Error message                                                  | Cause                                                                         | Resolution                                                                                                          |
| -------------------------------------------------------------- | ----------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
| `Payout balance information is unavailable for this paypoint.` | The paypoint has no balance data on record, or the data can't be read.        | Contact support to verify the paypoint's balance configuration.                                                     |
| `Transaction amount exceeds available payout balance.`         | The requested payout amount is greater than the paypoint's available balance. | [Deposit funds](/developers/api-reference/funding/deposit-funds) to increase the available balance before retrying. |

For standard payout errors, see [Pay Out troubleshooting](/guides/pay-out-troubleshooting).

## Webhooks

Wire and RTP payouts trigger the same webhook events as ACH payouts. There are no new or different events for instant rails. See [TransEvents](/guides/pay-out-transevents-reference) for the full list of payout events.

## Related resources

See these related resources to help you get the most out of Payabli.

* **[Manage payouts with the API](/guides/pay-out-developer-payouts-manage)** - Instant payouts use the same authorize-and-capture flow as standard payouts

- **[Pay Out statuses](/guides/pay-out-status-reference)** - Learn about Pay Out statuses
- **[Pay Out TransEvent reference](/guides/pay-out-transevents-reference)** - Learn about TransEvent values

* **[Audit payout transactions with the API](/guides/pay-out-developer-payouts-audit)** - Learn how to use the Payabli API to track and audit payout transactions