> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.mercoa.com/embedded-ap-ar/home/payment-methods/checks/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.mercoa.com/_mcp/server.

Mercoa supports check payments to vendors who do not accept ACH payments. Mercoa will print and mail checks to vendors on your behalf, or your customers (C2) can print and mail checks themselves.

## Key Considerations for Check Payments

Checks in Mercoa are printed using the account and routing number of the bank account you have linked to Mercoa.

Mercoa does not take custody of the funds, which allows your customer to maintain control of their cash flow.

Checks can only be printed against true checking accounts. Most BaaS providers' checking accounts are actually virtual accounts, which cannot be used for check payments.

We recommend printing a test check to deposit into your bank account to ensure that the check can be processed.

## Enabling Check Payments

Once a bank account has been linked to Mercoa, you can enable check payments by [updating](/api-reference/entity/payment-method/update) the `checkEnabled` field on the bank account.

### Request

POST [https://api.mercoa.com/entity/\{entityId}/paymentMethod](https://api.mercoa.com/entity/\{entityId}/paymentMethod)

**`BankAccountCheckEnabled`**

```curl BankAccountCheckEnabled
curl -X POST https://api.mercoa.com/entity/ent_8545a84e-a45f-41bf-bdf1-33b42a55812c/paymentMethod \
     -H "Authorization: Bearer <token>" \
     -H "Content-Type: application/json" \
     -d '{
  "type": "bankAccount",
  "accountNumber": "99988767623",
  "accountType": "CHECKING",
  "routingNumber": "12345678",
  "checkOptions": {
    "signatoryName": "John Doe",
    "enabled": true,
    "initialCheckNumber": 5000
  }
}'
```

**`BankAccountCheckEnabled`**

```python BankAccountCheckEnabled
import requests

url = "https://api.mercoa.com/entity/ent_8545a84e-a45f-41bf-bdf1-33b42a55812c/paymentMethod"

payload = {
    "type": "bankAccount",
    "accountNumber": "99988767623",
    "accountType": "CHECKING",
    "routingNumber": "12345678",
    "checkOptions": {
        "signatoryName": "John Doe",
        "enabled": True,
        "initialCheckNumber": 5000
    }
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

**`BankAccountCheckEnabled`**

```typescript BankAccountCheckEnabled
import { MercoaClient } from "@mercoa/javascript";

const client = new MercoaClient({ token: "YOUR_TOKEN" });
await client.entity.paymentMethod.create("ent_8545a84e-a45f-41bf-bdf1-33b42a55812c", {
    type: "bankAccount",
    routingNumber: "12345678",
    accountNumber: "99988767623",
    accountType: "CHECKING",
    checkOptions: {
        enabled: true,
        initialCheckNumber: 5000,
        signatoryName: "John Doe"
    }
});

```

**`BankAccountCheckEnabled`**

```go BankAccountCheckEnabled
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.mercoa.com/entity/ent_8545a84e-a45f-41bf-bdf1-33b42a55812c/paymentMethod"

	payload := strings.NewReader("{\n  \"type\": \"bankAccount\",\n  \"accountNumber\": \"99988767623\",\n  \"accountType\": \"CHECKING\",\n  \"routingNumber\": \"12345678\",\n  \"checkOptions\": {\n    \"signatoryName\": \"John Doe\",\n    \"enabled\": true,\n    \"initialCheckNumber\": 5000\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

**`BankAccountCheckEnabled`**

```ruby BankAccountCheckEnabled
require 'uri'
require 'net/http'

url = URI("https://api.mercoa.com/entity/ent_8545a84e-a45f-41bf-bdf1-33b42a55812c/paymentMethod")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"type\": \"bankAccount\",\n  \"accountNumber\": \"99988767623\",\n  \"accountType\": \"CHECKING\",\n  \"routingNumber\": \"12345678\",\n  \"checkOptions\": {\n    \"signatoryName\": \"John Doe\",\n    \"enabled\": true,\n    \"initialCheckNumber\": 5000\n  }\n}"

response = http.request(request)
puts response.read_body
```

**`BankAccountCheckEnabled`**

```java BankAccountCheckEnabled
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.mercoa.com/entity/ent_8545a84e-a45f-41bf-bdf1-33b42a55812c/paymentMethod")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"type\": \"bankAccount\",\n  \"accountNumber\": \"99988767623\",\n  \"accountType\": \"CHECKING\",\n  \"routingNumber\": \"12345678\",\n  \"checkOptions\": {\n    \"signatoryName\": \"John Doe\",\n    \"enabled\": true,\n    \"initialCheckNumber\": 5000\n  }\n}")
  .asString();
```

**`BankAccountCheckEnabled`**

```php BankAccountCheckEnabled
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.mercoa.com/entity/ent_8545a84e-a45f-41bf-bdf1-33b42a55812c/paymentMethod', [
  'body' => '{
  "type": "bankAccount",
  "accountNumber": "99988767623",
  "accountType": "CHECKING",
  "routingNumber": "12345678",
  "checkOptions": {
    "signatoryName": "John Doe",
    "enabled": true,
    "initialCheckNumber": 5000
  }
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

**`BankAccountCheckEnabled`**

```csharp BankAccountCheckEnabled
using RestSharp;

var client = new RestClient("https://api.mercoa.com/entity/ent_8545a84e-a45f-41bf-bdf1-33b42a55812c/paymentMethod");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"type\": \"bankAccount\",\n  \"accountNumber\": \"99988767623\",\n  \"accountType\": \"CHECKING\",\n  \"routingNumber\": \"12345678\",\n  \"checkOptions\": {\n    \"signatoryName\": \"John Doe\",\n    \"enabled\": true,\n    \"initialCheckNumber\": 5000\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

**`BankAccountCheckEnabled`**

```swift BankAccountCheckEnabled
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "type": "bankAccount",
  "accountNumber": "99988767623",
  "accountType": "CHECKING",
  "routingNumber": "12345678",
  "checkOptions": [
    "signatoryName": "John Doe",
    "enabled": true,
    "initialCheckNumber": 5000
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.mercoa.com/entity/ent_8545a84e-a45f-41bf-bdf1-33b42a55812c/paymentMethod")! 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()
```

For the vendor to receive a check, you will need to [create](/api-reference/entity/payment-method/create) a payment method for the vendor with the `type` set to `check`.

### Request

POST [https://api.mercoa.com/entity/\{entityId}/paymentMethod](https://api.mercoa.com/entity/\{entityId}/paymentMethod)

**`Check`**

```curl Check
curl -X POST https://api.mercoa.com/entity/ent_21661ac1-a2a8-4465-a6c0-64474ba8181d/paymentMethod \
     -H "Authorization: Bearer <token>" \
     -H "Content-Type: application/json" \
     -d '{
  "type": "check",
  "addressLine1": "123 Main St",
  "city": "New York",
  "country": "US",
  "payToTheOrderOf": "John Doe",
  "postalCode": "10001",
  "stateOrProvince": "NY",
  "addressLine2": "Apt 1"
}'
```

**`Check`**

```python Check
import requests

url = "https://api.mercoa.com/entity/ent_21661ac1-a2a8-4465-a6c0-64474ba8181d/paymentMethod"

payload = {
    "type": "check",
    "addressLine1": "123 Main St",
    "city": "New York",
    "country": "US",
    "payToTheOrderOf": "John Doe",
    "postalCode": "10001",
    "stateOrProvince": "NY",
    "addressLine2": "Apt 1"
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

**`Check`**

```typescript Check
import { MercoaClient } from "@mercoa/javascript";

const client = new MercoaClient({ token: "YOUR_TOKEN" });
await client.entity.paymentMethod.create("ent_21661ac1-a2a8-4465-a6c0-64474ba8181d", {
    type: "check",
    payToTheOrderOf: "John Doe",
    addressLine1: "123 Main St",
    addressLine2: "Apt 1",
    city: "New York",
    stateOrProvince: "NY",
    postalCode: "10001",
    country: "US"
});

```

**`Check`**

```go Check
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.mercoa.com/entity/ent_21661ac1-a2a8-4465-a6c0-64474ba8181d/paymentMethod"

	payload := strings.NewReader("{\n  \"type\": \"check\",\n  \"addressLine1\": \"123 Main St\",\n  \"city\": \"New York\",\n  \"country\": \"US\",\n  \"payToTheOrderOf\": \"John Doe\",\n  \"postalCode\": \"10001\",\n  \"stateOrProvince\": \"NY\",\n  \"addressLine2\": \"Apt 1\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

**`Check`**

```ruby Check
require 'uri'
require 'net/http'

url = URI("https://api.mercoa.com/entity/ent_21661ac1-a2a8-4465-a6c0-64474ba8181d/paymentMethod")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"type\": \"check\",\n  \"addressLine1\": \"123 Main St\",\n  \"city\": \"New York\",\n  \"country\": \"US\",\n  \"payToTheOrderOf\": \"John Doe\",\n  \"postalCode\": \"10001\",\n  \"stateOrProvince\": \"NY\",\n  \"addressLine2\": \"Apt 1\"\n}"

response = http.request(request)
puts response.read_body
```

**`Check`**

```java Check
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.mercoa.com/entity/ent_21661ac1-a2a8-4465-a6c0-64474ba8181d/paymentMethod")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"type\": \"check\",\n  \"addressLine1\": \"123 Main St\",\n  \"city\": \"New York\",\n  \"country\": \"US\",\n  \"payToTheOrderOf\": \"John Doe\",\n  \"postalCode\": \"10001\",\n  \"stateOrProvince\": \"NY\",\n  \"addressLine2\": \"Apt 1\"\n}")
  .asString();
```

**`Check`**

```php Check
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.mercoa.com/entity/ent_21661ac1-a2a8-4465-a6c0-64474ba8181d/paymentMethod', [
  'body' => '{
  "type": "check",
  "addressLine1": "123 Main St",
  "city": "New York",
  "country": "US",
  "payToTheOrderOf": "John Doe",
  "postalCode": "10001",
  "stateOrProvince": "NY",
  "addressLine2": "Apt 1"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

**`Check`**

```csharp Check
using RestSharp;

var client = new RestClient("https://api.mercoa.com/entity/ent_21661ac1-a2a8-4465-a6c0-64474ba8181d/paymentMethod");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"type\": \"check\",\n  \"addressLine1\": \"123 Main St\",\n  \"city\": \"New York\",\n  \"country\": \"US\",\n  \"payToTheOrderOf\": \"John Doe\",\n  \"postalCode\": \"10001\",\n  \"stateOrProvince\": \"NY\",\n  \"addressLine2\": \"Apt 1\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

**`Check`**

```swift Check
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "type": "check",
  "addressLine1": "123 Main St",
  "city": "New York",
  "country": "US",
  "payToTheOrderOf": "John Doe",
  "postalCode": "10001",
  "stateOrProvince": "NY",
  "addressLine2": "Apt 1"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.mercoa.com/entity/ent_21661ac1-a2a8-4465-a6c0-64474ba8181d/paymentMethod")! 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()
```

## Creating the Invoice

When creating the invoice, specify the source bank account as the `paymentSourceId` and the vendor's check payment method as the `paymentDestinationId`.

By default, checks will be printed and mailed to the vendor. This can be changed by setting the `paymentDestinationOptions` on the invoice.

## Printing the Check

Once the invoice has been created and is in the `SCHEDULED` status, you can generate the check PDF by using the [generate check](/api-reference/invoice/document/generate-check-pdf) endpoint.

Once this endpoint has been called, the invoice will be automatically marked as `PAID` regardless of the delivery method selected on the invoice. This is to prevent duplicate payments.

## Customizing Delivery Methods for Check Payments

Mercoa enables organizations to control which delivery methods (such as payment speeds and mail priorities) are available for check payments on a global and per-entity basis.

* **Global Configuration:** Set the default delivery methods for all entities using the [Payment Methods dashboard](https://mercoa.com/dashboard/paymentmethods).
* **Per-Entity Customization:** Override or restrict delivery methods for specific entities using per-entity feature customization.

This dual-layered approach ensures you can maintain broad organizational controls, while still tailoring payment options to unique compliance, cost, or operational needs for individual entities.

> **Use Case:**
> If you want to remove expedited or priority mail options for check disbursements for all entities, configure this in the global Payment Methods. To restrict or expand options for a particular entity (e.g., to comply with a vendor agreement or local regulation), override the global defaults using the entity's feature customization settings.

### Global Configuration

Admins can set the default available delivery methods for **all entities** within the Mercoa platform. This is managed from the [Payment Methods dashboard](https://mercoa.com/dashboard/paymentmethods) in the Mercoa dashboard.

**Enabling Available Delivery Methods for All Entities**

1. Go to the [Payment Methods dashboard](https://mercoa.com/dashboard/paymentmethods).
2. Under **Available Delivery Methods**, edit the list of available delivery methods to add or remove delivery methods.
3. Select the **Default Delivery Method**.
4. Save your changes.

The delivery methods selected here become the default options available to all entities within your organization. These defaults will apply unless a specific entity has its own customized delivery method settings.

### Per-Entity Customization

For exceptions or further customization, delivery methods can be overridden for specific entities via feature customization.
**Customizing Checks for a Specific Entity**

1. Go to the [entity’s information page](https://mercoa.com/dashboard/entities/) in the Mercoa Dashboard.
2. In **Feature Customization**, navigate to **Available Vendor Destinations**.
3. Under **check**, select the required **Available Delivery Methods**.
4. Select the **Default Delivery Method** among the selected **Available Delivery Methods**.
5. Save your changes.

The delivery methods chosen at the entity level will override the global defaults for that entity only. If no per-entity customization is set, the entity inherits the global settings defined in Payment Methods.