> 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

# Reissue payout

POST https://api-sandbox.payabli.com/api/MoneyOut/reissue
Content-Type: application/json

Reissues a payout transaction with a new payment method. This creates a new transaction linked to the original and marks the original transaction as reissued.

The original transaction must be in **Processing** or **Processed** status. The payment method in the request body is used directly. The endpoint doesn't fall back to vendor-managed payment methods.

The new transaction goes through the standard authorize-and-capture flow automatically. Both the original and new transactions are linked through their event histories for audit purposes.

Reference: https://docs.payabli.com/developers/api-reference/moneyout/reissue-a-payout-transaction

## Authentication

- `Authorization` header (bearer token, required)
- `requestToken` header (required) — Long-lived API token sent in the `requestToken` header. See [API token authentication](/developers/api-tokens).

## Servers

- `https://api-sandbox.payabli.com/api` (Sandbox, default)
- `https://api.payabli.com/api` (Production)

## Request

### Query parameters

- `transId` (string, required) — The transaction ID of the payout to reissue.

### Headers

- `idempotencyKey` (string, optional) — _Optional but recommended_ A unique ID that you can include to prevent duplicating objects or transactions in the case that a request is sent more than once. This key isn't generated in Payabli, you must generate it yourself. This key persists for 2 minutes. After 2 minutes, you can reuse the key if needed.

### Body (application/json)

- `paymentMethod` (object, required) — Payment method for reissuing a payout transaction. The reissue endpoint uses the payment method details directly. It doesn't fall back to the vendor's managed payment method. * `{ method: "vcard" }` - Reissue as a virtual card * `{ method: "check" }` - Reissue as a paper check * `{ method: "ach", achHolder: "...", achRouting: "...", achAccount: "...", achAccountType: "...", achHolderType: "..." }` - Reissue as ACH with bank details
  - `method` (string, required) — Payment method type. Must be `"ach"`, `"check"`, or `"vcard"`.
  - `achHolder` (string, optional) — Account holder name. Required when `method` is `"ach"`.
  - `achRouting` (string, optional) — Bank routing number (9 digits). Required when `method` is `"ach"`.
  - `achAccount` (string, optional) — Bank account number (8-17 digits). Required when `method` is `"ach"`.
  - `achAccountType` (string, optional) — Bank account type (`"checking"` or `"savings"`). Required when `method` is `"ach"`.
  - `achHolderType` (enum, optional, default: personal) — The bank's accountholder type: personal or business.
    - Allowed values: `personal`, `business`

## Response

### 200

Success

- `isSuccess` (boolean, required) — Boolean indicating whether the operation was successful. A `true` value indicates success. A `false` value indicates failure.
- `responseCode` (integer, required) — Code for the response. Learn more in [API Response Codes](/developers/api-reference/api-responses).
- `responseText` (string, required) — Response text for operation: 'Success' or 'Declined'.
- `responseData` (object, required)
  - `transactionId` (string, required) — The transaction ID of the newly created payout.
  - `status` (string, required) — The status of the new transaction.
  - `originalTransactionId` (string, optional) — The transaction ID of the original payout that was reissued.

## Examples

### ReissueAsACH

**Request**

```json
{
  "paymentMethod": {
    "method": "ach",
    "achHolder": "Acme Corp",
    "achRouting": "021000021",
    "achAccount": "9876543210",
    "achAccountType": "savings",
    "achHolderType": "business"
  }
}
```

**Response**

```json
{
  "isSuccess": true,
  "responseCode": 1,
  "responseText": "Success",
  "responseData": {
    "transactionId": "130-220",
    "status": "Authorized",
    "originalTransactionId": "129-219"
  }
}
```

**SDK Code**

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

async function main() {
    const client = new PayabliClient({
        clientId: "YOUR_CLIENT_ID",
        clientSecret: "YOUR_CLIENT_SECRET",
    });
    await client.moneyOut.reissueOut({
        transId: "129-219",
        paymentMethod: {
            method: "ach",
            achHolder: "Acme Corp",
            achRouting: "021000021",
            achAccount: "9876543210",
            achAccountType: "savings",
            achHolderType: "business",
        },
    });
}
main();

```

```python ReissueAsACH
from payabli import payabli, ReissuePaymentMethod

client = payabli(
    client_id="YOUR_CLIENT_ID",
    client_secret="YOUR_CLIENT_SECRET",
)

client.money_out.reissue_out(
    trans_id="129-219",
    payment_method=ReissuePaymentMethod(
        method="ach",
        ach_holder="Acme Corp",
        ach_routing="021000021",
        ach_account="9876543210",
        ach_account_type="savings",
        ach_holder_type="business",
    ),
)

```

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

import io.github.payabli.api.PayabliApiClient;
import io.github.payabli.api.resources.moneyout.requests.ReissueOutRequest;
import io.github.payabli.api.types.AchHolderType;
import io.github.payabli.api.types.ReissuePaymentMethod;

public class Example {
    public static void main(String[] args) {
        PayabliApiClient client = PayabliApiClient.withCredentials("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")
            .build()
        ;

        client.moneyOut().reissueOut(
            ReissueOutRequest
                .builder()
                .transId("129-219")
                .paymentMethod(
                    ReissuePaymentMethod
                        .builder()
                        .method("ach")
                        .achHolder("Acme Corp")
                        .achRouting("021000021")
                        .achAccount("9876543210")
                        .achAccountType("savings")
                        .achHolderType(AchHolderType.BUSINESS)
                        .build()
                )
                .build()
        );
    }
}
```

```ruby ReissueAsACH
require "payabli"

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

client.money_out.reissue_out(
  trans_id: "129-219",
  payment_method: {
    method_: "ach",
    ach_holder: "Acme Corp",
    ach_routing: "021000021",
    ach_account: "9876543210",
    ach_account_type: "savings",
    ach_holder_type: "business"
  }
)

```

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

public partial class Examples
{
    public async Task Example() {
        var client = new PayabliApiClient(
            clientId: "YOUR_CLIENT_ID",
            clientSecret: "YOUR_CLIENT_SECRET"
        );

        await client.MoneyOut.ReissueOutAsync(
            new ReissueOutRequest {
                TransId = "129-219",
                PaymentMethod = new ReissuePaymentMethod {
                    Method = "ach",
                    AchHolder = "Acme Corp",
                    AchRouting = "021000021",
                    AchAccount = "9876543210",
                    AchAccountType = "savings",
                    AchHolderType = AchHolderType.Business
                }
            }
        );
    }

}

```

```go ReissueAsACH
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.WithClientCredentials(
            "YOUR_CLIENT_ID",
            "YOUR_CLIENT_SECRET",
        ),
    )
    request := &payabli.ReissueOutRequest{
        TransId: "129-219",
        PaymentMethod: &payabli.ReissuePaymentMethod{
            Method: "ach",
            AchHolder: payabli.String(
                "Acme Corp",
            ),
            AchRouting: payabli.String(
                "021000021",
            ),
            AchAccount: payabli.String(
                "9876543210",
            ),
            AchAccountType: payabli.String(
                "savings",
            ),
            AchHolderType: payabli.AchHolderTypeBusiness.Ptr(),
        },
    }
    client.MoneyOut.ReissueOut(
        context.TODO(),
        request,
    )
}

```

```php ReissueAsACH
<?php

namespace Example;

use Payabli\PayabliClient;
use Payabli\MoneyOut\Requests\ReissueOutRequest;
use Payabli\Types\ReissuePaymentMethod;
use Payabli\Types\AchHolderType;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->moneyOut->reissueOut(
    new ReissueOutRequest([
        'transId' => '129-219',
        'paymentMethod' => new ReissuePaymentMethod([
            'method' => 'ach',
            'achHolder' => 'Acme Corp',
            'achRouting' => '021000021',
            'achAccount' => '9876543210',
            'achAccountType' => 'savings',
            'achHolderType' => AchHolderType::Business->value,
        ]),
    ]),
);

```

```swift ReissueAsACH
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["paymentMethod": [
    "method": "ach",
    "achHolder": "Acme Corp",
    "achRouting": "021000021",
    "achAccount": "9876543210",
    "achAccountType": "savings",
    "achHolderType": "business"
  ]] as [String : Any]

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

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

### ReissueAsCheck

**Request**

```json
{
  "paymentMethod": {
    "method": "check"
  }
}
```

**Response**

```json
{
  "isSuccess": true,
  "responseCode": 1,
  "responseText": "Success",
  "responseData": {
    "transactionId": "130-221",
    "status": "Authorized",
    "originalTransactionId": "129-219"
  }
}
```

**SDK Code**

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

async function main() {
    const client = new PayabliClient({
        clientId: "YOUR_CLIENT_ID",
        clientSecret: "YOUR_CLIENT_SECRET",
    });
    await client.moneyOut.reissueOut({
        transId: "129-219",
        paymentMethod: {
            method: "check",
        },
    });
}
main();

```

```python ReissueAsCheck
from payabli import payabli, ReissuePaymentMethod

client = payabli(
    client_id="YOUR_CLIENT_ID",
    client_secret="YOUR_CLIENT_SECRET",
)

client.money_out.reissue_out(
    trans_id="129-219",
    payment_method=ReissuePaymentMethod(
        method="check",
    ),
)

```

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

import io.github.payabli.api.PayabliApiClient;
import io.github.payabli.api.resources.moneyout.requests.ReissueOutRequest;
import io.github.payabli.api.types.ReissuePaymentMethod;

public class Example {
    public static void main(String[] args) {
        PayabliApiClient client = PayabliApiClient.withCredentials("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")
            .build()
        ;

        client.moneyOut().reissueOut(
            ReissueOutRequest
                .builder()
                .transId("129-219")
                .paymentMethod(
                    ReissuePaymentMethod
                        .builder()
                        .method("check")
                        .build()
                )
                .build()
        );
    }
}
```

```ruby ReissueAsCheck
require "payabli"

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

client.money_out.reissue_out(
  trans_id: "129-219",
  payment_method: {
    method_: "check"
  }
)

```

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

public partial class Examples
{
    public async Task Example() {
        var client = new PayabliApiClient(
            clientId: "YOUR_CLIENT_ID",
            clientSecret: "YOUR_CLIENT_SECRET"
        );

        await client.MoneyOut.ReissueOutAsync(
            new ReissueOutRequest {
                TransId = "129-219",
                PaymentMethod = new ReissuePaymentMethod {
                    Method = "check"
                }
            }
        );
    }

}

```

```go ReissueAsCheck
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.WithClientCredentials(
            "YOUR_CLIENT_ID",
            "YOUR_CLIENT_SECRET",
        ),
    )
    request := &payabli.ReissueOutRequest{
        TransId: "129-219",
        PaymentMethod: &payabli.ReissuePaymentMethod{
            Method: "check",
        },
    }
    client.MoneyOut.ReissueOut(
        context.TODO(),
        request,
    )
}

```

```php ReissueAsCheck
<?php

namespace Example;

use Payabli\PayabliClient;
use Payabli\MoneyOut\Requests\ReissueOutRequest;
use Payabli\Types\ReissuePaymentMethod;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->moneyOut->reissueOut(
    new ReissueOutRequest([
        'transId' => '129-219',
        'paymentMethod' => new ReissuePaymentMethod([
            'method' => 'check',
        ]),
    ]),
);

```

```swift ReissueAsCheck
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["paymentMethod": ["method": "check"]] as [String : Any]

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

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

### ReissueAsVCard

**Request**

```json
{
  "paymentMethod": {
    "method": "vcard"
  }
}
```

**Response**

```json
{
  "isSuccess": true,
  "responseCode": 1,
  "responseText": "Success",
  "responseData": {
    "transactionId": "130-222",
    "status": "Authorized",
    "originalTransactionId": "129-219"
  }
}
```

**SDK Code**

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

async function main() {
    const client = new PayabliClient({
        clientId: "YOUR_CLIENT_ID",
        clientSecret: "YOUR_CLIENT_SECRET",
    });
    await client.moneyOut.reissueOut({
        transId: "129-219",
        paymentMethod: {
            method: "vcard",
        },
    });
}
main();

```

```python ReissueAsVCard
from payabli import payabli, ReissuePaymentMethod

client = payabli(
    client_id="YOUR_CLIENT_ID",
    client_secret="YOUR_CLIENT_SECRET",
)

client.money_out.reissue_out(
    trans_id="129-219",
    payment_method=ReissuePaymentMethod(
        method="vcard",
    ),
)

```

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

import io.github.payabli.api.PayabliApiClient;
import io.github.payabli.api.resources.moneyout.requests.ReissueOutRequest;
import io.github.payabli.api.types.ReissuePaymentMethod;

public class Example {
    public static void main(String[] args) {
        PayabliApiClient client = PayabliApiClient.withCredentials("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")
            .build()
        ;

        client.moneyOut().reissueOut(
            ReissueOutRequest
                .builder()
                .transId("129-219")
                .paymentMethod(
                    ReissuePaymentMethod
                        .builder()
                        .method("vcard")
                        .build()
                )
                .build()
        );
    }
}
```

```ruby ReissueAsVCard
require "payabli"

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

client.money_out.reissue_out(
  trans_id: "129-219",
  payment_method: {
    method_: "vcard"
  }
)

```

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

public partial class Examples
{
    public async Task Example() {
        var client = new PayabliApiClient(
            clientId: "YOUR_CLIENT_ID",
            clientSecret: "YOUR_CLIENT_SECRET"
        );

        await client.MoneyOut.ReissueOutAsync(
            new ReissueOutRequest {
                TransId = "129-219",
                PaymentMethod = new ReissuePaymentMethod {
                    Method = "vcard"
                }
            }
        );
    }

}

```

```go ReissueAsVCard
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.WithClientCredentials(
            "YOUR_CLIENT_ID",
            "YOUR_CLIENT_SECRET",
        ),
    )
    request := &payabli.ReissueOutRequest{
        TransId: "129-219",
        PaymentMethod: &payabli.ReissuePaymentMethod{
            Method: "vcard",
        },
    }
    client.MoneyOut.ReissueOut(
        context.TODO(),
        request,
    )
}

```

```php ReissueAsVCard
<?php

namespace Example;

use Payabli\PayabliClient;
use Payabli\MoneyOut\Requests\ReissueOutRequest;
use Payabli\Types\ReissuePaymentMethod;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->moneyOut->reissueOut(
    new ReissueOutRequest([
        'transId' => '129-219',
        'paymentMethod' => new ReissuePaymentMethod([
            'method' => 'vcard',
        ]),
    ]),
);

```

```swift ReissueAsVCard
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["paymentMethod": ["method": "vcard"]] as [String : Any]

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

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