> This page is for version v2024-01-31.
> For other versions, use one of these documentation indexes:
> - v2024-05-25 (default): https://docs.monite.com/v-2024-05-25/llms.txt
> - v2024-01-31: https://docs.monite.com/v2024-01-31/llms.txt
> - v2023-09-01: https://docs.monite.com/v2023-09-01/llms.txt

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

# Get payables list from accounting system

GET https://api.sandbox.monite.com/v1/accounting/payables

Returns a list of accounts payable invoices (bills) that exist in the entity's accounting system. This requires that an accounting connection has been previously established. Refer to the [Accounting integration guide](https://docs.monite.com/accounting/integration/index) for details.

This endpoint only provides read-only access to the accounting system's data but does not pull those payables into Monite. You can use it to review the data in the accounting system and find out which of those payables already exist or do not exist in Monite.

Data is actual as of the date and time of the last accounting synchronization, which is specified by the `last_pull` value in the response from `GET /accounting_connections/{connection_id}`. To make sure you are accessing the most up-to-date accounting data, you can use `POST /accounting_connections/{connection_id}/sync` to trigger on-demand synchronization before getting the list of payables.

Reference: https://docs.monite.com/api/accounting-data-pull/get-accounting-payables

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Servers

- `https://api.sandbox.monite.com/v1` (sandbox, default)
- `https://api.monite.com/v1` (eu_production)
- `https://us.api.monite.com/v1` (na_production)

## Request

### Query parameters

- `limit` (integer, optional, default: 100) — Number of results per page.
- `offset` (integer, optional, default: 0) — Number of results to skip before selecting items to return.

### Headers

- `x-monite-version` (string, required)
- `x-monite-entity-id` (string, required) — The ID of the entity that owns the requested resource.

## Response

### 200

Successful Response

- `data` (list of AccountingPayable, required)

## Errors

### 422 Get Accounting Payables Request Unprocessable Entity Error

Validation Error

- `detail` (list of ValidationError, optional)

### 500 Get Accounting Payables Request Internal Server Error

Internal Server Error

- `error` (ErrorSchema, required)

## Types

### AccountingPayable

Details of an accounts payable invoice (bill) retrieved from an accounting system.

- `id` (string, required) — An internal identifier of the payable in the accounting system.
- `status` (string, required) — The status of the payable in the accounting system. Possible values: `open`, `draft`, `partially_paid`, `paid`, `unknown`, `void`.
- `total_amount` (double, required) — The total amount payable, including discounts and VAT/taxes.
- `amount_due` (double, optional) — Remaining amount to be paid.
- `currency` (string, optional) — ISO-4217 currency code of the payable.
- `currency_rate` (double, optional) — Rate to convert the total amount of the transaction into the entity's base currency at the time of the transaction.
- `due_date` (AccountingPayableDueDate, optional) — The payable's due date.
- `invoice_number` (string, optional) — Invoice number of the payable.
- `lines` (list of AccountingLineItem, optional)
- `memo` (string, optional) — Any additional information or business notes about the payable.
- `posted_date` (string, optional) — Date when the payable was added to the accounting service. This may differ from the payable creation date.
- `purchase_order_refs` (list of AccountingPurchaseOrderRef, optional) — A list of purchase orders linked to the payable, if any.
- `subtotal` (double, optional) — Amount payable, including discounts but excluding VAT/taxes.
- `tax_amount` (double, optional) — Total VAT or tax amount.
- `vendor_ref` (AccountingVendorRefObject, optional) — Information about the vendor from whom the payable was received.

### ValidationError

- `loc` (list of ValidationErrorLocItem, required)
- `msg` (string, required)
- `type` (string, required)

### ErrorSchema

- `message` (string, required)

### AccountingPayableDueDate

The payable's due date.

### AccountingLineItem

Contains the details of an invoice line item retrieved from an accounting system.

- `description` (string, optional) — The name or description of the product or service being invoiced.
- `discount_amount` (double, optional) — Discount amount for this line item (if any).
- `discount_percentage` (double, optional) — Discount percentage for this line item (if any).
- `ledger_account_id` (string, optional) — ID of the ledger account associated with this line item. You can use `GET /ledger_accounts/{ledger_account_id}` to get further details about this ledger account.
- `quantity` (double, optional) — The quantity of the product or service.
- `tax_rate_ref` (AccountingRefObject, optional) — An internal reference to the tax rate in the accounting system that the line item is linked to.
- `unit_amount` (double, optional) — The cost per unit of the product or service.

### AccountingPurchaseOrderRef

- `id` (string, required) — An internal ID of the purchase order in the accounting system.
- `name` (string, optional) — Reference number of the purchase order.

### AccountingVendorRefObject

- `id` (string, required) — A unique identifier of the vendor in the accounting system.
- `name` (string, optional) — Vendor name in the accounting system.

### ValidationErrorLocItem

### AccountingRefObject

- `id` (string, optional) — An internal ID of the tax rate in the accounting system.

## Examples

**Response**

```json
{
  "data": [
    {
      "id": "id",
      "status": "paid",
      "total_amount": 1.1,
      "amount_due": 1.1,
      "currency": "EUR",
      "currency_rate": 1.1,
      "due_date": "2024-01-15T09:30:00Z",
      "invoice_number": "invoice_number",
      "lines": [
        {
          "description": "Logo design",
          "discount_amount": 1.1,
          "discount_percentage": 1.1,
          "ledger_account_id": "ledger_account_id",
          "quantity": 1.1,
          "tax_rate_ref": {
            "id": "id"
          },
          "unit_amount": 1.1
        }
      ],
      "memo": "memo",
      "posted_date": "posted_date",
      "purchase_order_refs": [
        {
          "id": "10",
          "name": "PO-1234"
        }
      ],
      "subtotal": 1.1,
      "tax_amount": 1.1,
      "vendor_ref": {
        "id": "120",
        "name": "Acme Inc."
      }
    }
  ]
}
```

**SDK Code**

```python
import requests

url = "https://api.sandbox.monite.com/v1/accounting/payables"

headers = {
    "x-monite-version": "2024-01-31",
    "x-monite-entity-id": "9d2b4c8f-2087-4738-ba91-7359683c49a4",
    "Authorization": "Bearer <token>"
}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.sandbox.monite.com/v1/accounting/payables';
const options = {
  method: 'GET',
  headers: {
    'x-monite-version': '2024-01-31',
    'x-monite-entity-id': '9d2b4c8f-2087-4738-ba91-7359683c49a4',
    Authorization: 'Bearer <token>'
  }
};

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

```go
package main

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

func main() {

	url := "https://api.sandbox.monite.com/v1/accounting/payables"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-monite-version", "2024-01-31")
	req.Header.Add("x-monite-entity-id", "9d2b4c8f-2087-4738-ba91-7359683c49a4")
	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

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

url = URI("https://api.sandbox.monite.com/v1/accounting/payables")

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

request = Net::HTTP::Get.new(url)
request["x-monite-version"] = '2024-01-31'
request["x-monite-entity-id"] = '9d2b4c8f-2087-4738-ba91-7359683c49a4'
request["Authorization"] = 'Bearer <token>'

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

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

HttpResponse<String> response = Unirest.get("https://api.sandbox.monite.com/v1/accounting/payables")
  .header("x-monite-version", "2024-01-31")
  .header("x-monite-entity-id", "9d2b4c8f-2087-4738-ba91-7359683c49a4")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.sandbox.monite.com/v1/accounting/payables', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'x-monite-entity-id' => '9d2b4c8f-2087-4738-ba91-7359683c49a4',
    'x-monite-version' => '2024-01-31',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.sandbox.monite.com/v1/accounting/payables");
var request = new RestRequest(Method.GET);
request.AddHeader("x-monite-version", "2024-01-31");
request.AddHeader("x-monite-entity-id", "9d2b4c8f-2087-4738-ba91-7359683c49a4");
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "x-monite-version": "2024-01-31",
  "x-monite-entity-id": "9d2b4c8f-2087-4738-ba91-7359683c49a4",
  "Authorization": "Bearer <token>"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.sandbox.monite.com/v1/accounting/payables")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()
```