> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://interacdocs.nolimit.money/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://interacdocs.nolimit.money/_mcp/server.

# Send Interac

POST https://sandbox-payments.nolimit.money/interac/withdrawal
Content-Type: application/json

Using this API call you can initiate a new Interac withdrawal (Send). The response will provide the details of the send along with a password which can be used to accept the transaction.

## Required fields

Every request needs **2 headers** and **5 body fields**, and all of them are required. If any is missing or invalid, the request is refused and no withdrawal is created. The security question and answer are optional.

**Headers (both required)**

* **`x-api-key`**: your credentials, as `<kid>@<api-key>`. If it's missing you get `409` with message `Missing API key`; if it's wrong, `401`.
* **`Idempotency-Key`**: a new UUID v4 for every new withdrawal. If it's missing you get `400 MISSING_IDEMPOTENCY`; if it's not a UUID v4, `400 INVALID_IDEMPOTENCY_KEY`.

**Body fields (required)**

* **`firstName`** (string): the receiver's first name.
* **`lastName`** (string): the receiver's last name. If either name is missing you get `400 MISSING_NAME`.
* **`payoutEmail`** (string): the receiver's email address. Interac sends the payment to it. If it isn't a valid email address you get `422 INVALID_EMAIL`.
* **`memo`** (string): your own description of the transaction, 5 to 200 characters. Only letters, digits, spaces and `. # , $ @ '` are allowed (no `:` or `-`). Otherwise you get `400 MISSING_MEMO`.
* **`amount`** (number): the amount in CAD, for example `25` or `25.50`. Greater than 0, at most `9999`, with at most 2 decimals and no thousands separator. It also can't be more than your available balance, otherwise you get `400 INSUFFICIENT_FUNDS`. If it's out of range you get `422 INVALID_AMOUNT`; with more than 2 decimals, `422 INVALID_AMOUNT_PRECISION`.

**Body fields (optional)**

* **`securityQuestion`** (string) and **`securityAnswer`** (string): send **both or neither**. If either one is missing, we generate a question and answer for you. The answer needs at least 3 characters and no spaces; otherwise Interac doesn't accept the withdrawal and it is returned as `INCOMPLETE`.

Use real email addresses, including when testing in sandbox, and don't use the word "test" anywhere in an email field. Interac can reject the transaction, or ban the email address, when it sees test or made-up addresses. The `example.com` addresses on this page are placeholders only. Thank you for your understanding.

***

The headers must contain a unique `Idempotency-Key` (UUID v4) in order for the API call to be successfull. If reusing an older key the response will include the details of the transaction where the key was first used. It will not create a new transaction.

***

This Withdrawal (send) method will have a validation that the receiver will need to provide at the time of the claim of funds with their finnancial institution. The response received will contain a `securityAnswer` which will need to be decoded and supplied to the receiver.

On the sanbox environment we provide the `plainPassword` for ease of use, but on the production transactions this will not be present in the response.

Webhook callback example;

```
{
  "withdrawal": {
    "id": "d850c75f-8ce0-404a-81e9-c6744f2c02c7",
    "customerEmail": "jane.doe@example.com",
    "postedAmount": "18.00",
    "status": "COMPLETED",
    "referenceNumber": null,
    "memo": "Testing",
    "createdAt": "2025-12-15T10:01:13.519Z",
    "postedAt": "2025-12-15T10:01:16.687Z"
  },
  "partner_balance": "67.00"
}

```

A custom `securityQuestion` and `securityAnswer` can be created by the requester by specifying **both** values in the payload. They are optional parameters and the system will generate random ones if they are not specified.

When a custom `securityQuestion` and `securityAnswer` pair needs to be created by the requester, **both** values need to be specified in the payload. Specifying a value just for one of them will render the system to generate a generic pair.

***

## 409 Conflict

This endpoint returns `409 Conflict` for four different reasons. The HTTP status alone doesn't tell you which one, so always branch on `error.code`.

* **`DUPLICATE_PENDING_TRANSACTION_AMOUNT_MISMATCH`**: the customer already has an open withdrawal for a **different** amount. See the full explanation below.
* **`IDEMPOTENCY_IN_PROGRESS`**: a request with this `Idempotency-Key` is still being processed. Wait a few seconds, then retry with the same key and the same body.
* **`BLACKLISTED`**: the `payoutEmail` is blocked. Don't retry. Contact NoLimit support if you think this is a mistake.
* **`BAD_REQUEST`** with message `Missing API key`: the `x-api-key` header was not sent. Send `x-api-key: <kid>@<api-key>`.

Withdrawals have no check for a reused `Idempotency-Key` with a different body. If you send a key that was already used, you get the **original** response back, even if the body is different, and no new withdrawal is created. Always generate a new key for a new withdrawal.

### DUPLICATE\_PENDING\_TRANSACTION\_AMOUNT\_MISMATCH

#### The rule

A customer can have only **one open withdrawal** from you at a time.

* **Customer** means the `payoutEmail`, compared case-insensitively, within your partner account. Withdrawals created by other NoLimit partners don't count.
* **One check covers both withdrawal endpoints.** An open withdrawal sent with `POST /withdrawal` (by email) blocks a new `POST /withdrawal/account` (to a bank account) for the same `payoutEmail`, and the other way round.
* **Open** means the withdrawal is not final yet: `PENDING`, `AUTHENTICATED`, `SENT`, `FULFILLED` or `UNKNOWN`.
* Withdrawals that are `COMPLETED`, `REJECTED`, `DECLINED`, `CANCELLED` or `INCOMPLETE` never block a new withdrawal.
* Only withdrawals count here. An open deposit from the same email doesn't block a withdrawal. Deposits have their own, separate check with the same rules (see `POST /request`).

#### What happens when the customer already has an open withdrawal

**Same amount as an open withdrawal:** no new withdrawal is created and your balance is not debited again. You get `201 Created` with the **existing** withdrawal.

* The `transactionId` in this response is the original withdrawal's ID, **not** the `Idempotency-Key` you just sent. Always store the `transactionId` from the response instead of assuming it equals your key.
* The response carries the **existing** withdrawal's `securityQuestion` and `securityAnswer`. Any security question and answer you sent in the new request are ignored. Give the customer the answer from this response.
* Your new `Idempotency-Key` is now linked to that existing withdrawal. Replaying it returns the same withdrawal.

**Different amount:** the request is refused with `409 Conflict`:

```json
{
  "success": 0,
  "error": {
    "code": "DUPLICATE_PENDING_TRANSACTION_AMOUNT_MISMATCH",
    "message": "These transactions are not finalized: 00000000-0000-4000-8000-000000000001. Either mark them as rejected or completed."
  }
}
```

* `error.message` lists **every** open withdrawal for this customer, separated by `, `, newest first. This is the only place the blocking IDs are returned.
* "Mark them as rejected or completed" refers to the **customer**: they complete the open withdrawal by accepting the money, or reject it by declining it. You can't close a withdrawal through the API.

#### What the 409 does not mean

* **The open withdrawal has not failed.** It is still live, and the customer can still accept it. Don't mark it as failed on your side.
* **No new withdrawal was created, and your balance was not debited.** There is no new `transactionId` to track.

#### What happens to your request

* The `Idempotency-Key` you sent is released, not stored. You can send the same key again later with the same body.
* Every retry for a different amount returns the same `409` until **all** the listed withdrawals are final.

#### How the open withdrawal ends

Only one of these ends it:

1. The customer accepts the money from the Interac email. It becomes `COMPLETED`.
2. The customer declines it, or their bank does. It becomes `DECLINED` or `REJECTED`.
3. Nobody acts on it for 30 days, and Interac expires it.
4. It was sent to the wrong email address and you ask NoLimit support to cancel it. This is possible only while it is still `SENT`, and it becomes `CANCELLED`.

There is no API endpoint to cancel an open withdrawal.

#### Recommended handling

1. **Branch on the code.** Treat `DUPLICATE_PENDING_TRANSACTION_AMOUNT_MISMATCH` as "the customer has an unaccepted payout", not as a failed payout.
2. **Find the open withdrawal.** Take the transaction ID or IDs from `error.message`, or from your own records for that email. Call `GET /withdrawal/{id}` to get its `postedAmount` and `status`.
3. **Tell the customer.** For example: "You have a payout of \$50.00 waiting. Accept it from the Interac email before requesting another one."
4. **Unblock on the final status.** When the webhook or `GET /withdrawal/{id}` shows a final status, you can send the customer a new withdrawal for any amount.

#### Avoid the 409 in the first place

* Before sending a withdrawal, check your own records for an open withdrawal to that email.
* If you need to pay the customer more while a payout is still open, wait until the customer accepts it, then send the difference as a new withdrawal.
* Remind customers to accept their payouts, so open withdrawals are resolved sooner.

#### Order of checks

Checks run in this order. Each one can stop the request before the next:

1. API key (`401`, or `409` when the header is missing)
2. Blacklist (`409 BLACKLISTED`)
3. Body validation, including `DAILY_LIMIT_EXCEEDED` (`400` or `422`)
4. `Idempotency-Key` (`400`, or `409 IDEMPOTENCY_IN_PROGRESS`)
5. Withdrawals availability (`403 WITHDRAWAL_UNAVAILABLE`)
6. Open-withdrawal check (`201` with the existing withdrawal, or `409 DUPLICATE_PENDING_TRANSACTION_AMOUNT_MISMATCH`)
7. Balance (`400 INSUFFICIENT_FUNDS`)

Reference: https://interacdocs.nolimit.money/partner-interac-api/send-interac

## Servers

- `https://sandbox-payments.nolimit.money/interac` (Sandbox, default)
- `https://payments.nolimit.money/interac` (Production)

## Request

### Headers

- `x-api-key` (string, required) — Your credentials, as `<kid>@<api-key>`.
- `Idempotency-Key` (string, required) — A new UUID v4 for every new withdrawal. Reusing a key returns the original response, even with a different body, and creates no new withdrawal.

### Body (application/json)

This endpoint expects an object.

- `firstName` (string, required) — The receiver's first name.
- `lastName` (string, required) — The receiver's last name.
- `payoutEmail` (string, required) — The receiver's email address. Use a real email address, even in sandbox, and don't include the word "test". Interac can reject the transaction or ban the address otherwise.
- `memo` (string, required) — Your own description of the transaction, 5 to 200 characters. Only letters, digits, spaces and `. # , $ @ '` are allowed.
- `amount` (double, required) — Amount in CAD. Greater than 0, at most 9999, with at most 2 decimals. Can't be more than your available balance.
- `securityQuestion` (string, optional) — Send together with `securityAnswer`. If either is missing, a question and answer are generated for you.
- `securityAnswer` (string, optional) — Send together with `securityQuestion`. At least 3 characters, no spaces.

## Response

### 201

Created

- `data` (WithdrawalPostResponsesContentApplicationJsonSchemaData, required)
- `success` (integer, required)

## Errors

### 409 Conflict Error

Conflict. Check `error.code`; see the 409 Conflict section above.

- `success` (integer, required) — Always 0 for errors.
- `error` (WithdrawalPostResponsesContentApplicationJsonSchemaError, required)

## Types

### WithdrawalPostResponsesContentApplicationJsonSchemaData

- `transactionId` (string, required)
- `status` (string, required)
- `payoutEmail` (string, required)
- `postedAmount` (integer, required)
- `securityQuestion` (string, required)
- `securityAnswer` (WithdrawalPostResponsesContentApplicationJsonSchemaDataSecurityAnswer, required)
- `plainPassword` (string, required)
- `createdAt` (datetime, required)
- `updatedAt` (datetime, required)

### WithdrawalPostResponsesContentApplicationJsonSchemaError

- `code` (string, required) — Machine-readable reason. Branch on this value.
- `message` (string, optional) — Human-readable detail. For DUPLICATE_PENDING_TRANSACTION_AMOUNT_MISMATCH, lists the open withdrawal IDs.

### WithdrawalPostResponsesContentApplicationJsonSchemaDataSecurityAnswer

- `alg` (string, required)
- `iv` (string, required)
- `ciphertext` (string, required)
- `tag` (string, required)

## Examples

**Request**

```json
{
  "firstName": "Jane",
  "lastName": "Doe",
  "payoutEmail": "jane.doe@example.com",
  "memo": "Testing",
  "amount": 18,
  "securityQuestion": "What city were you born in?",
  "securityAnswer": "Paris"
}
```

**Response**

```json
{
  "data": {
    "transactionId": "d850c75f-8ce0-404a-81e9-c6744f2c02c7",
    "status": "PENDING",
    "payoutEmail": "jane.doe@example.com",
    "postedAmount": 18,
    "securityQuestion": "What is the secret code?",
    "securityAnswer": {
      "alg": "AES-256-GCM",
      "iv": "JV7HN9j+24SchO/J",
      "ciphertext": "5SPoz5DKy67nxtwph46+Xg==",
      "tag": "1qG/fM76IOk8DS+B3jwN6A=="
    },
    "plainPassword": "6HPYH6YL8MBM789V",
    "createdAt": "2025-12-15T10:01:13.519Z",
    "updatedAt": "2025-12-15T10:01:16.687Z"
  },
  "success": 1
}
```

**SDK Code**

```python Send Interac_example
import requests

url = "https://sandbox-payments.nolimit.money/interac/withdrawal"

payload = {
    "firstName": "Jane",
    "lastName": "Doe",
    "payoutEmail": "jane.doe@example.com",
    "memo": "Testing",
    "amount": 18,
    "securityQuestion": "What city were you born in?",
    "securityAnswer": "Paris"
}
headers = {
    "Idempotency-Key": "6f1c2b8e-4a7d-4c3e-9b2f-8d5a1e7c0f42",
    "x-api-key": "<kid>@<api-key>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Send Interac_example
const url = 'https://sandbox-payments.nolimit.money/interac/withdrawal';
const options = {
  method: 'POST',
  headers: {
    'Idempotency-Key': '6f1c2b8e-4a7d-4c3e-9b2f-8d5a1e7c0f42',
    'x-api-key': '<kid>@<api-key>',
    'Content-Type': 'application/json'
  },
  body: '{"firstName":"Jane","lastName":"Doe","payoutEmail":"jane.doe@example.com","memo":"Testing","amount":18,"securityQuestion":"What city were you born in?","securityAnswer":"Paris"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Send Interac_example
package main

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

func main() {

	url := "https://sandbox-payments.nolimit.money/interac/withdrawal"

	payload := strings.NewReader("{\n  \"firstName\": \"Jane\",\n  \"lastName\": \"Doe\",\n  \"payoutEmail\": \"jane.doe@example.com\",\n  \"memo\": \"Testing\",\n  \"amount\": 18,\n  \"securityQuestion\": \"What city were you born in?\",\n  \"securityAnswer\": \"Paris\"\n}")

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

	req.Header.Add("Idempotency-Key", "6f1c2b8e-4a7d-4c3e-9b2f-8d5a1e7c0f42")
	req.Header.Add("x-api-key", "<kid>@<api-key>")
	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))

}
```

```ruby Send Interac_example
require 'uri'
require 'net/http'

url = URI("https://sandbox-payments.nolimit.money/interac/withdrawal")

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

request = Net::HTTP::Post.new(url)
request["Idempotency-Key"] = '6f1c2b8e-4a7d-4c3e-9b2f-8d5a1e7c0f42'
request["x-api-key"] = '<kid>@<api-key>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"firstName\": \"Jane\",\n  \"lastName\": \"Doe\",\n  \"payoutEmail\": \"jane.doe@example.com\",\n  \"memo\": \"Testing\",\n  \"amount\": 18,\n  \"securityQuestion\": \"What city were you born in?\",\n  \"securityAnswer\": \"Paris\"\n}"

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

```java Send Interac_example
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://sandbox-payments.nolimit.money/interac/withdrawal")
  .header("Idempotency-Key", "6f1c2b8e-4a7d-4c3e-9b2f-8d5a1e7c0f42")
  .header("x-api-key", "<kid>@<api-key>")
  .header("Content-Type", "application/json")
  .body("{\n  \"firstName\": \"Jane\",\n  \"lastName\": \"Doe\",\n  \"payoutEmail\": \"jane.doe@example.com\",\n  \"memo\": \"Testing\",\n  \"amount\": 18,\n  \"securityQuestion\": \"What city were you born in?\",\n  \"securityAnswer\": \"Paris\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://sandbox-payments.nolimit.money/interac/withdrawal', [
  'body' => '{
  "firstName": "Jane",
  "lastName": "Doe",
  "payoutEmail": "jane.doe@example.com",
  "memo": "Testing",
  "amount": 18,
  "securityQuestion": "What city were you born in?",
  "securityAnswer": "Paris"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'Idempotency-Key' => '6f1c2b8e-4a7d-4c3e-9b2f-8d5a1e7c0f42',
    'x-api-key' => '<kid>@<api-key>',
  ],
]);

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

```csharp Send Interac_example
using RestSharp;

var client = new RestClient("https://sandbox-payments.nolimit.money/interac/withdrawal");
var request = new RestRequest(Method.POST);
request.AddHeader("Idempotency-Key", "6f1c2b8e-4a7d-4c3e-9b2f-8d5a1e7c0f42");
request.AddHeader("x-api-key", "<kid>@<api-key>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"firstName\": \"Jane\",\n  \"lastName\": \"Doe\",\n  \"payoutEmail\": \"jane.doe@example.com\",\n  \"memo\": \"Testing\",\n  \"amount\": 18,\n  \"securityQuestion\": \"What city were you born in?\",\n  \"securityAnswer\": \"Paris\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Send Interac_example
import Foundation

let headers = [
  "Idempotency-Key": "6f1c2b8e-4a7d-4c3e-9b2f-8d5a1e7c0f42",
  "x-api-key": "<kid>@<api-key>",
  "Content-Type": "application/json"
]
let parameters = [
  "firstName": "Jane",
  "lastName": "Doe",
  "payoutEmail": "jane.doe@example.com",
  "memo": "Testing",
  "amount": 18,
  "securityQuestion": "What city were you born in?",
  "securityAnswer": "Paris"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://sandbox-payments.nolimit.money/interac/withdrawal")! 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()
```