> 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

# Manage payout subscriptions with the API

> Learn how to create, update, and delete automated recurring payouts to vendors with the Payabli API

Payout subscriptions are bill pay on autopilot. You set the vendor, amount, payment method, and frequency, and the system runs it on schedule. Supported payment methods are ACH, vCard, and check. Each payout goes through the same batching and funding flow as a manual payout.

This is useful any time you're paying the same vendor the same amount on a regular cadence. Common examples include property management companies paying owners their rent share every month, recurring contractor payments, commissions, or regular vendor bills.

This guide covers the key operations for managing payout subscriptions through the API.

## Considerations

When working with payout subscriptions, keep the following in mind:

* Payout subscriptions are linked to a vendor. Pass a `vendorId` or `vendorNumber` in the `vendorData` object to associate the subscription with an existing vendor.
* The `billData` array is optional. If you omit it and don't set `doNotCreateBills` to `true`, the system creates a bill automatically.
* The `paymentMethod` object supports `ach`, `vcard`, and `check` methods. The `managed` method isn't supported for payout subscriptions.
* Payout subscription transactions typically run between 2:30 AM and 3:30 AM Eastern time.

## Create a payout subscription

Send a POST request to `/api/PayoutSubscription` to create a new payout subscription. See the [API reference](/developers/api-reference/payout-subscription/create-payout-subscription) for full documentation.

#### ACH payout subscription

Creates a recurring payout subscription using ACH bank transfer.

### Request

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

```curl ACHPayoutSubscription
curl -X POST https://api-sandbox.payabli.com/api/PayoutSubscription \
     -H "Content-Type: application/json" \
     -d '{
  "entryPoint": "8cfec329267",
  "paymentMethod": {
    "method": "ach",
    "achHolder": "Herman Coatings",
    "achRouting": "021000021",
    "achAccount": "3453445666",
    "achAccountType": "checking"
  },
  "vendorData": {
    "vendorId": 456
  },
  "paymentDetails": {
    "totalAmount": 500,
    "serviceFee": 0,
    "currency": "USD"
  },
  "billData": [
    {
      "dueDate": "2025-08-15",
      "invoiceDate": "2025-08-01",
      "invoiceNumber": "INV-2345",
      "netAmount": "500"
    }
  ],
  "scheduleDetails": {
    "startDate": "09/01/2027",
    "endDate": "09/01/2026",
    "frequency": "monthly"
  }
}'
```

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

async function main() {
    const client = new PayabliClient();
    await client.payoutSubscription.createPayoutSubscription({
        entryPoint: "8cfec329267",
        paymentMethod: {
            method: "ach",
            achHolder: "Herman Coatings",
            achRouting: "021000021",
            achAccount: "3453445666",
            achAccountType: "checking",
        },
        paymentDetails: {
            totalAmount: 500,
            serviceFee: 0,
            currency: "USD",
        },
        vendorData: {
            vendorId: 456,
        },
        billData: [
            {
                dueDate: "2025-08-15",
                invoiceDate: "2025-08-01",
                invoiceNumber: "INV-2345",
                netAmount: "500",
            },
        ],
        scheduleDetails: {
            startDate: "09/01/2027",
            endDate: "09/01/2026",
            frequency: "monthly",
        },
    });
}
main();

```

```python ACHPayoutSubscription
from payabli import payabli, AuthorizePaymentMethod, PayoutPaymentDetail, RequestOutAuthorizeVendorData, BillPayOutDataRequest, PayoutScheduleDetail
import datetime

client = payabli()

client.payout_subscription.create_payout_subscription(
    entry_point="8cfec329267",
    payment_method=AuthorizePaymentMethod(
        method="ach",
        ach_holder="Herman Coatings",
        ach_routing="021000021",
        ach_account="3453445666",
        ach_account_type="checking",
    ),
    payment_details=PayoutPaymentDetail(
        total_amount=500,
        service_fee=0,
        currency="USD",
    ),
    vendor_data=RequestOutAuthorizeVendorData(
        vendor_id=456,
    ),
    bill_data=[
        BillPayOutDataRequest(
            due_date=datetime.date.fromisoformat("2025-08-15"),
            invoice_date=datetime.date.fromisoformat("2025-08-01"),
            invoice_number="INV-2345",
            net_amount="500",
        )
    ],
    schedule_details=PayoutScheduleDetail(
        start_date="09/01/2027",
        end_date="09/01/2026",
        frequency="monthly",
    ),
)

```

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

import io.github.payabli.api.PayabliApiClient;
import io.github.payabli.api.resources.payoutsubscription.requests.RequestPayoutSchedule;
import io.github.payabli.api.types.AuthorizePaymentMethod;
import io.github.payabli.api.types.BillPayOutDataRequest;
import io.github.payabli.api.types.Frequency;
import io.github.payabli.api.types.PayoutPaymentDetail;
import io.github.payabli.api.types.PayoutScheduleDetail;
import io.github.payabli.api.types.RequestOutAuthorizeVendorData;
import java.util.Arrays;
import java.util.Optional;

public class Example {
    public static void main(String[] args) {
        PayabliApiClient client = PayabliApiClient
            .builder()
            .build();

        client.payoutSubscription().createPayoutSubscription(
            RequestPayoutSchedule
                .builder()
                .entryPoint("8cfec329267")
                .paymentMethod(
                    AuthorizePaymentMethod
                        .builder()
                        .method("ach")
                        .achHolder("Herman Coatings")
                        .achRouting("021000021")
                        .achAccount("3453445666")
                        .achAccountType("checking")
                        .build()
                )
                .vendorData(
                    RequestOutAuthorizeVendorData
                        .builder()
                        .vendorId(456)
                        .build()
                )
                .paymentDetails(
                    PayoutPaymentDetail
                        .builder()
                        .totalAmount(500.0)
                        .serviceFee(0.0)
                        .currency("USD")
                        .build()
                )
                .billData(
                    Optional.of(
                        Arrays.asList(
                            BillPayOutDataRequest
                                .builder()
                                .dueDate("2025-08-15")
                                .invoiceDate("2025-08-01")
                                .invoiceNumber("INV-2345")
                                .netAmount("500")
                                .build()
                        )
                    )
                )
                .scheduleDetails(
                    PayoutScheduleDetail
                        .builder()
                        .startDate("09/01/2027")
                        .endDate("09/01/2026")
                        .frequency(Frequency.MONTHLY)
                        .build()
                )
                .build()
        );
    }
}
```

```ruby ACHPayoutSubscription
require "payabli"

client = Payabli::Client.new

client.payout_subscription.create_payout_subscription(
  entry_point: "8cfec329267",
  payment_method: {
    method_: "ach",
    ach_holder: "Herman Coatings",
    ach_routing: "021000021",
    ach_account: "3453445666",
    ach_account_type: "checking"
  },
  payment_details: {
    total_amount: 500,
    service_fee: 0,
    currency: "USD"
  },
  vendor_data: {
    vendor_id: 456
  },
  bill_data: [{
    due_date: "2025-08-15",
    invoice_date: "2025-08-01",
    invoice_number: "INV-2345",
    net_amount: "500"
  }],
  schedule_details: {
    start_date: "09/01/2027",
    end_date: "09/01/2026",
    frequency: "monthly"
  }
)

```

```csharp ACHPayoutSubscription
using PayabliApi;
using System.Threading.Tasks;
using System.Collections.Generic;
using System;

public partial class Examples
{
    public async Task Example() {
        var client = new PayabliApiClient();

        await client.PayoutSubscription.CreatePayoutSubscriptionAsync(
            new RequestPayoutSchedule {
                EntryPoint = "8cfec329267",
                PaymentMethod = new AuthorizePaymentMethod {
                    Method = "ach",
                    AchHolder = "Herman Coatings",
                    AchRouting = "021000021",
                    AchAccount = "3453445666",
                    AchAccountType = "checking"
                },
                PaymentDetails = new PayoutPaymentDetail {
                    TotalAmount = 500,
                    ServiceFee = 0,
                    Currency = "USD"
                },
                VendorData = new RequestOutAuthorizeVendorData {
                    VendorId = 456
                },
                BillData = new List<BillPayOutDataRequest>(){
                    new BillPayOutDataRequest {
                        DueDate = DateOnly.Parse("2025-08-15"),
                        InvoiceDate = DateOnly.Parse("2025-08-01"),
                        InvoiceNumber = "INV-2345",
                        NetAmount = "500"
                    },
                }
                ,
                ScheduleDetails = new PayoutScheduleDetail {
                    StartDate = "09/01/2027",
                    EndDate = "09/01/2026",
                    Frequency = Frequency.Monthly
                }
            }
        );
    }

}

```

```go ACHPayoutSubscription
package example

import (
    context "context"

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

func do() {
    client := client.NewClient()
    request := &payabli.RequestPayoutSchedule{
        EntryPoint: "8cfec329267",
        PaymentMethod: &payabli.AuthorizePaymentMethod{
            Method: "ach",
            AchHolder: payabli.String(
                "Herman Coatings",
            ),
            AchRouting: payabli.String(
                "021000021",
            ),
            AchAccount: payabli.String(
                "3453445666",
            ),
            AchAccountType: payabli.String(
                "checking",
            ),
        },
        VendorData: &payabli.RequestOutAuthorizeVendorData{
            VendorId: payabli.Int(
                456,
            ),
        },
        PaymentDetails: &payabli.PayoutPaymentDetail{
            TotalAmount: 500,
            ServiceFee: payabli.Float64(
                0,
            ),
            Currency: payabli.String(
                "USD",
            ),
        },
        BillData: []*payabli.BillPayOutDataRequest{
            &payabli.BillPayOutDataRequest{
                DueDate: payabli.Time(
                    payabli.MustParseDate(
                        "2025-08-15",
                    ),
                ),
                InvoiceDate: payabli.Time(
                    payabli.MustParseDate(
                        "2025-08-01",
                    ),
                ),
                InvoiceNumber: payabli.String(
                    "INV-2345",
                ),
                NetAmount: payabli.String(
                    "500",
                ),
            },
        },
        ScheduleDetails: &payabli.PayoutScheduleDetail{
            StartDate: payabli.String(
                "09/01/2027",
            ),
            EndDate: payabli.String(
                "09/01/2026",
            ),
            Frequency: payabli.FrequencyMonthly.Ptr(),
        },
    }
    client.PayoutSubscription.CreatePayoutSubscription(
        context.TODO(),
        request,
    )
}

```

```php ACHPayoutSubscription
<?php

namespace Example;

use Payabli\PayabliClient;
use Payabli\PayoutSubscription\Requests\RequestPayoutSchedule;
use Payabli\Types\AuthorizePaymentMethod;
use Payabli\Types\PayoutPaymentDetail;
use Payabli\Types\RequestOutAuthorizeVendorData;
use Payabli\Types\BillPayOutDataRequest;
use DateTime;
use Payabli\Types\PayoutScheduleDetail;
use Payabli\Types\Frequency;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->payoutSubscription->createPayoutSubscription(
    new RequestPayoutSchedule([
        'entryPoint' => '8cfec329267',
        'paymentMethod' => new AuthorizePaymentMethod([
            'method' => 'ach',
            'achHolder' => 'Herman Coatings',
            'achRouting' => '021000021',
            'achAccount' => '3453445666',
            'achAccountType' => 'checking',
        ]),
        'paymentDetails' => new PayoutPaymentDetail([
            'totalAmount' => 500,
            'serviceFee' => 0,
            'currency' => 'USD',
        ]),
        'vendorData' => new RequestOutAuthorizeVendorData([
            'vendorId' => 456,
        ]),
        'billData' => [
            new BillPayOutDataRequest([
                'dueDate' => new DateTime('2025-08-15'),
                'invoiceDate' => new DateTime('2025-08-01'),
                'invoiceNumber' => 'INV-2345',
                'netAmount' => '500',
            ]),
        ],
        'scheduleDetails' => new PayoutScheduleDetail([
            'startDate' => '09/01/2027',
            'endDate' => '09/01/2026',
            'frequency' => Frequency::Monthly->value,
        ]),
    ]),
);

```

```swift ACHPayoutSubscription
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  "entryPoint": "8cfec329267",
  "paymentMethod": [
    "method": "ach",
    "achHolder": "Herman Coatings",
    "achRouting": "021000021",
    "achAccount": "3453445666",
    "achAccountType": "checking"
  ],
  "vendorData": ["vendorId": 456],
  "paymentDetails": [
    "totalAmount": 500,
    "serviceFee": 0,
    "currency": "USD"
  ],
  "billData": [
    [
      "dueDate": "2025-08-15",
      "invoiceDate": "2025-08-01",
      "invoiceNumber": "INV-2345",
      "netAmount": "500"
    ]
  ],
  "scheduleDetails": [
    "startDate": "09/01/2027",
    "endDate": "09/01/2026",
    "frequency": "monthly"
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/PayoutSubscription")! 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()
```

#### vCard payout subscription

Creates a recurring payout subscription using a virtual card.

### Request

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

```curl VcardPayoutSubscription
curl -X POST https://api-sandbox.payabli.com/api/PayoutSubscription \
     -H "Content-Type: application/json" \
     -d '{
  "entryPoint": "8cfec329267",
  "paymentMethod": {
    "method": "vcard"
  },
  "vendorData": {
    "vendorId": 456
  },
  "paymentDetails": {
    "totalAmount": 250,
    "serviceFee": 0
  },
  "billData": [
    {
      "dueDate": "2025-09-01",
      "invoiceDate": "2025-08-15",
      "invoiceNumber": "INV-2345",
      "netAmount": "250"
    }
  ],
  "scheduleDetails": {
    "startDate": "09/01/2027",
    "endDate": "untilcancelled",
    "frequency": "weekly"
  }
}'
```

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

async function main() {
    const client = new PayabliClient();
    await client.payoutSubscription.createPayoutSubscription({
        entryPoint: "8cfec329267",
        paymentMethod: {
            method: "vcard",
        },
        paymentDetails: {
            totalAmount: 250,
            serviceFee: 0,
        },
        vendorData: {
            vendorId: 456,
        },
        billData: [
            {
                dueDate: "2025-09-01",
                invoiceDate: "2025-08-15",
                invoiceNumber: "INV-2345",
                netAmount: "250",
            },
        ],
        scheduleDetails: {
            startDate: "09/01/2027",
            endDate: "untilcancelled",
            frequency: "weekly",
        },
    });
}
main();

```

```python VcardPayoutSubscription
from payabli import payabli, AuthorizePaymentMethod, PayoutPaymentDetail, RequestOutAuthorizeVendorData, BillPayOutDataRequest, PayoutScheduleDetail
import datetime

client = payabli()

client.payout_subscription.create_payout_subscription(
    entry_point="8cfec329267",
    payment_method=AuthorizePaymentMethod(
        method="vcard",
    ),
    payment_details=PayoutPaymentDetail(
        total_amount=250,
        service_fee=0,
    ),
    vendor_data=RequestOutAuthorizeVendorData(
        vendor_id=456,
    ),
    bill_data=[
        BillPayOutDataRequest(
            due_date=datetime.date.fromisoformat("2025-09-01"),
            invoice_date=datetime.date.fromisoformat("2025-08-15"),
            invoice_number="INV-2345",
            net_amount="250",
        )
    ],
    schedule_details=PayoutScheduleDetail(
        start_date="09/01/2027",
        end_date="untilcancelled",
        frequency="weekly",
    ),
)

```

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

import io.github.payabli.api.PayabliApiClient;
import io.github.payabli.api.resources.payoutsubscription.requests.RequestPayoutSchedule;
import io.github.payabli.api.types.AuthorizePaymentMethod;
import io.github.payabli.api.types.BillPayOutDataRequest;
import io.github.payabli.api.types.Frequency;
import io.github.payabli.api.types.PayoutPaymentDetail;
import io.github.payabli.api.types.PayoutScheduleDetail;
import io.github.payabli.api.types.RequestOutAuthorizeVendorData;
import java.util.Arrays;
import java.util.Optional;

public class Example {
    public static void main(String[] args) {
        PayabliApiClient client = PayabliApiClient
            .builder()
            .build();

        client.payoutSubscription().createPayoutSubscription(
            RequestPayoutSchedule
                .builder()
                .entryPoint("8cfec329267")
                .paymentMethod(
                    AuthorizePaymentMethod
                        .builder()
                        .method("vcard")
                        .build()
                )
                .vendorData(
                    RequestOutAuthorizeVendorData
                        .builder()
                        .vendorId(456)
                        .build()
                )
                .paymentDetails(
                    PayoutPaymentDetail
                        .builder()
                        .totalAmount(250.0)
                        .serviceFee(0.0)
                        .build()
                )
                .billData(
                    Optional.of(
                        Arrays.asList(
                            BillPayOutDataRequest
                                .builder()
                                .dueDate("2025-09-01")
                                .invoiceDate("2025-08-15")
                                .invoiceNumber("INV-2345")
                                .netAmount("250")
                                .build()
                        )
                    )
                )
                .scheduleDetails(
                    PayoutScheduleDetail
                        .builder()
                        .startDate("09/01/2027")
                        .endDate("untilcancelled")
                        .frequency(Frequency.WEEKLY)
                        .build()
                )
                .build()
        );
    }
}
```

```ruby VcardPayoutSubscription
require "payabli"

client = Payabli::Client.new

client.payout_subscription.create_payout_subscription(
  entry_point: "8cfec329267",
  payment_method: {
    method_: "vcard"
  },
  payment_details: {
    total_amount: 250,
    service_fee: 0
  },
  vendor_data: {
    vendor_id: 456
  },
  bill_data: [{
    due_date: "2025-09-01",
    invoice_date: "2025-08-15",
    invoice_number: "INV-2345",
    net_amount: "250"
  }],
  schedule_details: {
    start_date: "09/01/2027",
    end_date: "untilcancelled",
    frequency: "weekly"
  }
)

```

```csharp VcardPayoutSubscription
using PayabliApi;
using System.Threading.Tasks;
using System.Collections.Generic;
using System;

public partial class Examples
{
    public async Task Example() {
        var client = new PayabliApiClient();

        await client.PayoutSubscription.CreatePayoutSubscriptionAsync(
            new RequestPayoutSchedule {
                EntryPoint = "8cfec329267",
                PaymentMethod = new AuthorizePaymentMethod {
                    Method = "vcard"
                },
                PaymentDetails = new PayoutPaymentDetail {
                    TotalAmount = 250,
                    ServiceFee = 0
                },
                VendorData = new RequestOutAuthorizeVendorData {
                    VendorId = 456
                },
                BillData = new List<BillPayOutDataRequest>(){
                    new BillPayOutDataRequest {
                        DueDate = DateOnly.Parse("2025-09-01"),
                        InvoiceDate = DateOnly.Parse("2025-08-15"),
                        InvoiceNumber = "INV-2345",
                        NetAmount = "250"
                    },
                }
                ,
                ScheduleDetails = new PayoutScheduleDetail {
                    StartDate = "09/01/2027",
                    EndDate = "untilcancelled",
                    Frequency = Frequency.Weekly
                }
            }
        );
    }

}

```

```go VcardPayoutSubscription
package example

import (
    context "context"

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

func do() {
    client := client.NewClient()
    request := &payabli.RequestPayoutSchedule{
        EntryPoint: "8cfec329267",
        PaymentMethod: &payabli.AuthorizePaymentMethod{
            Method: "vcard",
        },
        VendorData: &payabli.RequestOutAuthorizeVendorData{
            VendorId: payabli.Int(
                456,
            ),
        },
        PaymentDetails: &payabli.PayoutPaymentDetail{
            TotalAmount: 250,
            ServiceFee: payabli.Float64(
                0,
            ),
        },
        BillData: []*payabli.BillPayOutDataRequest{
            &payabli.BillPayOutDataRequest{
                DueDate: payabli.Time(
                    payabli.MustParseDate(
                        "2025-09-01",
                    ),
                ),
                InvoiceDate: payabli.Time(
                    payabli.MustParseDate(
                        "2025-08-15",
                    ),
                ),
                InvoiceNumber: payabli.String(
                    "INV-2345",
                ),
                NetAmount: payabli.String(
                    "250",
                ),
            },
        },
        ScheduleDetails: &payabli.PayoutScheduleDetail{
            StartDate: payabli.String(
                "09/01/2027",
            ),
            EndDate: payabli.String(
                "untilcancelled",
            ),
            Frequency: payabli.FrequencyWeekly.Ptr(),
        },
    }
    client.PayoutSubscription.CreatePayoutSubscription(
        context.TODO(),
        request,
    )
}

```

```php VcardPayoutSubscription
<?php

namespace Example;

use Payabli\PayabliClient;
use Payabli\PayoutSubscription\Requests\RequestPayoutSchedule;
use Payabli\Types\AuthorizePaymentMethod;
use Payabli\Types\PayoutPaymentDetail;
use Payabli\Types\RequestOutAuthorizeVendorData;
use Payabli\Types\BillPayOutDataRequest;
use DateTime;
use Payabli\Types\PayoutScheduleDetail;
use Payabli\Types\Frequency;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->payoutSubscription->createPayoutSubscription(
    new RequestPayoutSchedule([
        'entryPoint' => '8cfec329267',
        'paymentMethod' => new AuthorizePaymentMethod([
            'method' => 'vcard',
        ]),
        'paymentDetails' => new PayoutPaymentDetail([
            'totalAmount' => 250,
            'serviceFee' => 0,
        ]),
        'vendorData' => new RequestOutAuthorizeVendorData([
            'vendorId' => 456,
        ]),
        'billData' => [
            new BillPayOutDataRequest([
                'dueDate' => new DateTime('2025-09-01'),
                'invoiceDate' => new DateTime('2025-08-15'),
                'invoiceNumber' => 'INV-2345',
                'netAmount' => '250',
            ]),
        ],
        'scheduleDetails' => new PayoutScheduleDetail([
            'startDate' => '09/01/2027',
            'endDate' => 'untilcancelled',
            'frequency' => Frequency::Weekly->value,
        ]),
    ]),
);

```

```swift VcardPayoutSubscription
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  "entryPoint": "8cfec329267",
  "paymentMethod": ["method": "vcard"],
  "vendorData": ["vendorId": 456],
  "paymentDetails": [
    "totalAmount": 250,
    "serviceFee": 0
  ],
  "billData": [
    [
      "dueDate": "2025-09-01",
      "invoiceDate": "2025-08-15",
      "invoiceNumber": "INV-2345",
      "netAmount": "250"
    ]
  ],
  "scheduleDetails": [
    "startDate": "09/01/2027",
    "endDate": "untilcancelled",
    "frequency": "weekly"
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/PayoutSubscription")! 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 the payout subscription ID in `responseData` and the vendor's ID in `customerId`.

### Response (200)

```json
{
  "responseText": "Success",
  "responseData": 42,
  "isSuccess": true,
  "customerId": 4440
}
```

## Pause a payout subscription

Pausing a payout subscription stops all future payouts until you unpause it. The next payment date isn't calculated automatically while paused.

To pause a payout subscription, send a PUT request to `/api/PayoutSubscription/{id}` with `setPause` set to `true`. To resume, send another PUT request with `setPause` set to `false`.

#### Pause

### Request

PUT [https://api-sandbox.payabli.com/api/PayoutSubscription/\{id}](https://api-sandbox.payabli.com/api/PayoutSubscription/\{id})

```curl PausePayoutSubscription
curl -X PUT https://api-sandbox.payabli.com/api/PayoutSubscription/42 \
     -H "Content-Type: application/json" \
     -d '{
  "setPause": true
}'
```

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

async function main() {
    const client = new PayabliClient();
    await client.payoutSubscription.updatePayoutSubscription(42, {
        setPause: true,
    });
}
main();

```

```python PausePayoutSubscription
from payabli import payabli

client = payabli()

client.payout_subscription.update_payout_subscription(
    id=42,
    set_pause=True,
)

```

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

import io.github.payabli.api.PayabliApiClient;
import io.github.payabli.api.resources.payoutsubscription.requests.UpdatePayoutSubscriptionBody;

public class Example {
    public static void main(String[] args) {
        PayabliApiClient client = PayabliApiClient
            .builder()
            .build();

        client.payoutSubscription().updatePayoutSubscription(
            42L,
            UpdatePayoutSubscriptionBody
                .builder()
                .setPause(true)
                .build()
        );
    }
}
```

```ruby PausePayoutSubscription
require "payabli"

client = Payabli::Client.new

client.payout_subscription.update_payout_subscription(
  id: 42,
  set_pause: true
)

```

```csharp PausePayoutSubscription
using PayabliApi;
using System.Threading.Tasks;

public partial class Examples
{
    public async Task Example() {
        var client = new PayabliApiClient();

        await client.PayoutSubscription.UpdatePayoutSubscriptionAsync(
            id: 42L,
            request: new UpdatePayoutSubscriptionBody {
                SetPause = true
            }
        );
    }

}

```

```go PausePayoutSubscription
package example

import (
    context "context"

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

func do() {
    client := client.NewClient()
    request := &payabli.UpdatePayoutSubscriptionBody{
        SetPause: payabli.Bool(
            true,
        ),
    }
    client.PayoutSubscription.UpdatePayoutSubscription(
        context.TODO(),
        int64(42),
        request,
    )
}

```

```php PausePayoutSubscription
<?php

namespace Example;

use Payabli\PayabliClient;
use Payabli\PayoutSubscription\Requests\UpdatePayoutSubscriptionBody;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->payoutSubscription->updatePayoutSubscription(
    42,
    new UpdatePayoutSubscriptionBody([
        'setPause' => true,
    ]),
);

```

```swift PausePayoutSubscription
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = ["setPause": true] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/PayoutSubscription/42")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```

#### Unpause

### Request

PUT [https://api-sandbox.payabli.com/api/PayoutSubscription/\{id}](https://api-sandbox.payabli.com/api/PayoutSubscription/\{id})

```curl UnpausePayoutSubscription
curl -X PUT https://api-sandbox.payabli.com/api/PayoutSubscription/42 \
     -H "Content-Type: application/json" \
     -d '{
  "setPause": false
}'
```

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

async function main() {
    const client = new PayabliClient();
    await client.payoutSubscription.updatePayoutSubscription(42, {
        setPause: false,
    });
}
main();

```

```python UnpausePayoutSubscription
from payabli import payabli

client = payabli()

client.payout_subscription.update_payout_subscription(
    id=42,
    set_pause=False,
)

```

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

import io.github.payabli.api.PayabliApiClient;
import io.github.payabli.api.resources.payoutsubscription.requests.UpdatePayoutSubscriptionBody;

public class Example {
    public static void main(String[] args) {
        PayabliApiClient client = PayabliApiClient
            .builder()
            .build();

        client.payoutSubscription().updatePayoutSubscription(
            42L,
            UpdatePayoutSubscriptionBody
                .builder()
                .setPause(false)
                .build()
        );
    }
}
```

```ruby UnpausePayoutSubscription
require "payabli"

client = Payabli::Client.new

client.payout_subscription.update_payout_subscription(
  id: 42,
  set_pause: false
)

```

```csharp UnpausePayoutSubscription
using PayabliApi;
using System.Threading.Tasks;

public partial class Examples
{
    public async Task Example() {
        var client = new PayabliApiClient();

        await client.PayoutSubscription.UpdatePayoutSubscriptionAsync(
            id: 42L,
            request: new UpdatePayoutSubscriptionBody {
                SetPause = false
            }
        );
    }

}

```

```go UnpausePayoutSubscription
package example

import (
    context "context"

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

func do() {
    client := client.NewClient()
    request := &payabli.UpdatePayoutSubscriptionBody{
        SetPause: payabli.Bool(
            false,
        ),
    }
    client.PayoutSubscription.UpdatePayoutSubscription(
        context.TODO(),
        int64(42),
        request,
    )
}

```

```php UnpausePayoutSubscription
<?php

namespace Example;

use Payabli\PayabliClient;
use Payabli\PayoutSubscription\Requests\UpdatePayoutSubscriptionBody;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->payoutSubscription->updatePayoutSubscription(
    42,
    new UpdatePayoutSubscriptionBody([
        'setPause' => false,
    ]),
);

```

```swift UnpausePayoutSubscription
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = ["setPause": false] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/PayoutSubscription/42")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```

## Get payout subscription details

Send a GET request to `/api/PayoutSubscription/{id}` to retrieve details about a specific payout subscription.

This example gets the details for the payout subscription with ID `42`.

### Request

GET [https://api-sandbox.payabli.com/api/PayoutSubscription/\{id}](https://api-sandbox.payabli.com/api/PayoutSubscription/\{id})

```curl
curl https://api-sandbox.payabli.com/api/PayoutSubscription/42
```

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

async function main() {
    const client = new PayabliClient();
    await client.payoutSubscription.getPayoutSubscription(42);
}
main();

```

```python
from payabli import payabli

client = payabli()

client.payout_subscription.get_payout_subscription(
    id=42,
)

```

```java
package com.example.usage;

import io.github.payabli.api.PayabliApiClient;

public class Example {
    public static void main(String[] args) {
        PayabliApiClient client = PayabliApiClient
            .builder()
            .build();

        client.payoutSubscription().getPayoutSubscription(42L);
    }
}
```

```ruby
require "payabli"

client = Payabli::Client.new

client.payout_subscription.get_payout_subscription(id: 42)

```

```csharp
using PayabliApi;
using System.Threading.Tasks;

public partial class Examples
{
    public async Task Example() {
        var client = new PayabliApiClient();

        await client.PayoutSubscription.GetPayoutSubscriptionAsync(
            42L
        );
    }

}

```

```go
package example

import (
    context "context"

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

func do() {
    client := client.NewClient()
    client.PayoutSubscription.GetPayoutSubscription(
        context.TODO(),
        int64(42),
    )
}

```

```php
<?php

namespace Example;

use Payabli\PayabliClient;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->payoutSubscription->getPayoutSubscription(
    42,
);

```

```swift
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/PayoutSubscription/42")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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 all available details about the payout subscription. See the [API reference](/developers/api-reference/payout-subscription/get-payout-subscription) for a full response example.

### Response (200)

```json
{
  "responseText": "Success",
  "isSuccess": true,
  "responseData": {
    "startDate": "2025-09-01T00:00:00Z",
    "endDate": "2026-09-01T00:00:00Z",
    "nextDate": "2025-10-01T00:00:00Z",
    "lastRun": "2025-09-01T06:00:00Z",
    "idOutSubscription": 42,
    "status": 1,
    "events": [
      {
        "description": "TransferCreated",
        "eventTime": "2025-09-01T06:00:00Z",
        "extraData": null,
        "refData": "refData",
        "source": "api"
      }
    ],
    "vendor": {
      "VendorNumber": "VEN-123",
      "Name1": "Herman's Coatings",
      "Name2": "Herman's Coating Supply Company, LLC",
      "EIN": "123456789",
      "Phone": "2125551234",
      "Email": "example@email.com",
      "RemitEmail": null,
      "Address1": "123 Ocean Drive",
      "Address2": "Suite 400",
      "City": "Bristol",
      "State": "GA",
      "Zip": "31113",
      "Country": "US",
      "Mcc": "7777",
      "LocationCode": "LOC123",
      "Contacts": [
        {
          "ContactName": "Eric Martinez",
          "ContactEmail": "eric@martinezcoatings.com",
          "ContactTitle": "Owner",
          "ContactPhone": "5555555555"
        }
      ],
      "BillingData": {
        "id": 123456,
        "nickname": "Main Checking Account",
        "bankName": "Example Bank",
        "routingAccount": "123456789",
        "accountNumber": "9876543210",
        "typeAccount": "Checking",
        "bankAccountHolderName": "John Doe",
        "bankAccountHolderType": "Business",
        "bankAccountFunction": 2,
        "verified": true,
        "status": 1,
        "services": [],
        "default": true,
        "accountId": "bank-account-001"
      },
      "PaymentMethod": null,
      "VendorStatus": 1,
      "VendorId": 456,
      "EnrollmentStatus": null,
      "Summary": {
        "ActiveBills": 2,
        "PendingBills": 4,
        "InTransitBills": 3,
        "PaidBills": 18,
        "OverdueBills": 1,
        "ApprovedBills": 5,
        "DisapprovedBills": 1,
        "TotalBills": 34,
        "ActiveBillsAmount": 1250.75,
        "PendingBillsAmount": 2890.5,
        "InTransitBillsAmount": 1675.25,
        "PaidBillsAmount": 15420.8,
        "OverdueBillsAmount": 425,
        "ApprovedBillsAmount": 3240.9,
        "DisapprovedBillsAmount": 180,
        "TotalBillsAmount": 25083.2
      },
      "PaypointLegalname": "Sunshine Services, LLC",
      "PaypointDbaname": "Sunshine Gutters",
      "PaypointEntryname": "d193cf9a46",
      "ParentOrgName": "PropertyManager Pro",
      "ParentOrgId": 1000,
      "CreatedDate": "2022-07-01T15:00:01Z",
      "LastUpdated": "2022-07-01T15:00:01Z",
      "remitAddress1": "123 Walnut Street",
      "remitAddress2": "Suite 900",
      "remitCity": "Miami",
      "remitState": "FL",
      "remitZip": "31113",
      "remitCountry": "US",
      "payeeName1": "payeeName1",
      "payeeName2": "payeeName2",
      "customField1": "",
      "customField2": "",
      "customerVendorAccount": "123-456",
      "InternalReferenceId": 1000000,
      "PaymentPortalUrl": "https://greenfield-landscaping.com/pay",
      "CardAccepted": "yes",
      "AchAccepted": "unable to determine",
      "EnrichmentStatus": "fully_enriched",
      "EnrichedBy": "web_search",
      "EnrichedAt": "2026-03-05T14:22:10Z",
      "EnrichmentId": "enrich-3890-a1b2c3d4",
      "additionalData": null,
      "externalPaypointID": "Paypoint-100",
      "StoredMethods": []
    },
    "billData": [
      {
        "invoiceDate": "2025-08-01",
        "dueDate": "2025-08-15",
        "billId": 54323,
        "invoiceNumber": "INV-2345",
        "netAmount": "500"
      }
    ],
    "externalPaypointID": "d193cf9a46-10",
    "method": "ach",
    "paypointId": 3040,
    "totalAmount": 500,
    "netAmount": 500,
    "feeAmount": 0,
    "paymentData": {
      "AccountType": "checking",
      "HolderName": "Herman Coatings",
      "Initiator": "merchant",
      "MaskedAccount": "XXXXXX5666",
      "paymentDetails": {
        "totalAmount": 500,
        "currency": "USD",
        "serviceFee": 0
      },
      "Sequence": "subsequent",
      "StoredMethodUsageType": "recurring"
    },
    "frequency": "monthly",
    "totalCycles": 12,
    "leftCycles": 11,
    "entrypageId": 0,
    "untilCancelled": false,
    "lastUpdated": "2025-08-01T12:00:00Z",
    "createdAt": "2025-08-01T12:00:00Z",
    "paypointLegalname": "Sunshine Services, LLC",
    "paypointDbaname": "Sunshine Gutters",
    "paypointEntryname": "d193cf9a46",
    "parentOrgName": "PropertyManager Pro",
    "parentOrgId": 236,
    "source": "api"
  }
}
```

## Update a payout subscription

Send a PUT request to `/api/PayoutSubscription/{id}` to change an existing payout subscription's payment details, schedule, or payment method. See the [API reference](/developers/api-reference/payout-subscription/update-payout-subscription) for full documentation.

### Request

PUT [https://api-sandbox.payabli.com/api/PayoutSubscription/\{id}](https://api-sandbox.payabli.com/api/PayoutSubscription/\{id})

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

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

async function main() {
    const client = new PayabliClient();
    await client.payoutSubscription.updatePayoutSubscription(42, {
        paymentDetails: {
            totalAmount: 750,
            serviceFee: 0,
        },
        scheduleDetails: {
            startDate: "01/01/2027",
            endDate: "12/31/2027",
            frequency: "monthly",
        },
    });
}
main();

```

```python UpdatePayoutSubscription
from payabli import payabli, PayoutPaymentDetail, PayoutScheduleDetail

client = payabli()

client.payout_subscription.update_payout_subscription(
    id=42,
    payment_details=PayoutPaymentDetail(
        total_amount=750,
        service_fee=0,
    ),
    schedule_details=PayoutScheduleDetail(
        start_date="01/01/2027",
        end_date="12/31/2027",
        frequency="monthly",
    ),
)

```

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

import io.github.payabli.api.PayabliApiClient;
import io.github.payabli.api.resources.payoutsubscription.requests.UpdatePayoutSubscriptionBody;
import io.github.payabli.api.types.Frequency;
import io.github.payabli.api.types.PayoutPaymentDetail;
import io.github.payabli.api.types.PayoutScheduleDetail;

public class Example {
    public static void main(String[] args) {
        PayabliApiClient client = PayabliApiClient
            .builder()
            .build();

        client.payoutSubscription().updatePayoutSubscription(
            42L,
            UpdatePayoutSubscriptionBody
                .builder()
                .paymentDetails(
                    PayoutPaymentDetail
                        .builder()
                        .totalAmount(750.0)
                        .serviceFee(0.0)
                        .build()
                )
                .scheduleDetails(
                    PayoutScheduleDetail
                        .builder()
                        .startDate("01/01/2027")
                        .endDate("12/31/2027")
                        .frequency(Frequency.MONTHLY)
                        .build()
                )
                .build()
        );
    }
}
```

```ruby UpdatePayoutSubscription
require "payabli"

client = Payabli::Client.new

client.payout_subscription.update_payout_subscription(
  id: 42,
  payment_details: {
    total_amount: 750,
    service_fee: 0
  },
  schedule_details: {
    start_date: "01/01/2027",
    end_date: "12/31/2027",
    frequency: "monthly"
  }
)

```

```csharp UpdatePayoutSubscription
using PayabliApi;
using System.Threading.Tasks;

public partial class Examples
{
    public async Task Example() {
        var client = new PayabliApiClient();

        await client.PayoutSubscription.UpdatePayoutSubscriptionAsync(
            id: 42L,
            request: new UpdatePayoutSubscriptionBody {
                PaymentDetails = new PayoutPaymentDetail {
                    TotalAmount = 750,
                    ServiceFee = 0
                },
                ScheduleDetails = new PayoutScheduleDetail {
                    StartDate = "01/01/2027",
                    EndDate = "12/31/2027",
                    Frequency = Frequency.Monthly
                }
            }
        );
    }

}

```

```go UpdatePayoutSubscription
package example

import (
    context "context"

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

func do() {
    client := client.NewClient()
    request := &payabli.UpdatePayoutSubscriptionBody{
        PaymentDetails: &payabli.PayoutPaymentDetail{
            TotalAmount: 750,
            ServiceFee: payabli.Float64(
                0,
            ),
        },
        ScheduleDetails: &payabli.PayoutScheduleDetail{
            StartDate: payabli.String(
                "01/01/2027",
            ),
            EndDate: payabli.String(
                "12/31/2027",
            ),
            Frequency: payabli.FrequencyMonthly.Ptr(),
        },
    }
    client.PayoutSubscription.UpdatePayoutSubscription(
        context.TODO(),
        int64(42),
        request,
    )
}

```

```php UpdatePayoutSubscription
<?php

namespace Example;

use Payabli\PayabliClient;
use Payabli\PayoutSubscription\Requests\UpdatePayoutSubscriptionBody;
use Payabli\Types\PayoutPaymentDetail;
use Payabli\Types\PayoutScheduleDetail;
use Payabli\Types\Frequency;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->payoutSubscription->updatePayoutSubscription(
    42,
    new UpdatePayoutSubscriptionBody([
        'paymentDetails' => new PayoutPaymentDetail([
            'totalAmount' => 750,
            'serviceFee' => 0,
        ]),
        'scheduleDetails' => new PayoutScheduleDetail([
            'startDate' => '01/01/2027',
            'endDate' => '12/31/2027',
            'frequency' => Frequency::Monthly->value,
        ]),
    ]),
);

```

```swift UpdatePayoutSubscription
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  "paymentDetails": [
    "totalAmount": 750,
    "serviceFee": 0
  ],
  "scheduleDetails": [
    "startDate": "01/01/2027",
    "endDate": "12/31/2027",
    "frequency": "monthly"
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/PayoutSubscription/42")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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 the payout subscription ID in `responseData` and the vendor's ID in `customerId`.

### Response (200)

```json
{
  "responseText": "Success",
  "isSuccess": true,
  "responseData": "42",
  "customerId": 4440
}
```

## Delete a payout subscription

Send a DELETE request to `/api/PayoutSubscription/{id}` to cancel a payout subscription and stop future payouts. See the [API reference](/developers/api-reference/payout-subscription/delete-payout-subscription) for full documentation.

This example deletes the payout subscription with the ID `42`.

### Request

DELETE [https://api-sandbox.payabli.com/api/PayoutSubscription/\{id}](https://api-sandbox.payabli.com/api/PayoutSubscription/\{id})

```curl
curl -X DELETE https://api-sandbox.payabli.com/api/PayoutSubscription/42
```

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

async function main() {
    const client = new PayabliClient();
    await client.payoutSubscription.deletePayoutSubscription(42);
}
main();

```

```python
from payabli import payabli

client = payabli()

client.payout_subscription.delete_payout_subscription(
    id=42,
)

```

```java
package com.example.usage;

import io.github.payabli.api.PayabliApiClient;

public class Example {
    public static void main(String[] args) {
        PayabliApiClient client = PayabliApiClient
            .builder()
            .build();

        client.payoutSubscription().deletePayoutSubscription(42L);
    }
}
```

```ruby
require "payabli"

client = Payabli::Client.new

client.payout_subscription.delete_payout_subscription(id: 42)

```

```csharp
using PayabliApi;
using System.Threading.Tasks;

public partial class Examples
{
    public async Task Example() {
        var client = new PayabliApiClient();

        await client.PayoutSubscription.DeletePayoutSubscriptionAsync(
            42L
        );
    }

}

```

```go
package example

import (
    context "context"

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

func do() {
    client := client.NewClient()
    client.PayoutSubscription.DeletePayoutSubscription(
        context.TODO(),
        int64(42),
    )
}

```

```php
<?php

namespace Example;

use Payabli\PayabliClient;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->payoutSubscription->deletePayoutSubscription(
    42,
);

```

```swift
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/PayoutSubscription/42")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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 deletion returns a response that includes the payout subscription ID (in `responseData`).

### Response (200)

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

## Related resources

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

#### Prerequisites

* **[Manage vendors with the API](/guides/pay-out-developer-vendors-manage)** - Payout subscriptions are linked to a vendor, so you need to understand vendors first

#### References

* **[Pay Out schemas](/guides/pay-out-schemas-overview)** - Learn about money out statuses and events and how they work together
* **[Pay Out statuses](/guides/pay-out-status-reference)** - Learn about Pay Out statuses

#### Related topics

* **[Manage payouts with the API](/guides/pay-out-developer-payouts-manage)** - Learn how to use the Payabli API to create, capture, and cancel payout transactions
* **[Manage bills with the API](/guides/pay-out-developer-bills-manage)** - Learn how to add and manage bills for vendors via the API

#### Often confused with

**Manage subscriptions with the API** - Pay In subscriptions collect payments from customers, payout subscriptions send payments to vendors See [Manage subscriptions with the API](/guides/pay-in-developer-subscriptions-manage)