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

# Get invoice list from accounting system

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

Returns a list of invoices 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 invoices into Monite. You can use it to review the data in the accounting system and find out which of those invoices 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 invoice list.

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

## 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 AccountingReceivable, required)

## Errors

### 422 Get Accounting Receivables Request Unprocessable Entity Error

Validation Error

- `detail` (list of ValidationError, optional)

### 500 Get Accounting Receivables Request Internal Server Error

Internal Server Error

- `error` (ErrorSchema, required)

## Types

### AccountingReceivable

Invoice details retrieved from an accounting system.

- `id` (string, optional) — An internal identifier of the invoice in the accounting system.
- `currency` (string, optional) — ISO-4217 currency code of the invoice.
- `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.
- `customer_ref` (AccountingCustomerRefObject, optional) — Information about the customer that the invoice was sent to.
- `due_date` (AccountingReceivableDueDate, optional) — Invoice due date.
- `invoice_number` (string, optional) — Invoice document number.
- `lines` (list of AccountingLineItem, optional)
- `memo` (string, optional) — Any additional information or business notes about the invoice.
- `pass_through` (map from string to any, optional) — An object containing additional invoice data returned by the accounting system. This sometimes includes custom invoice fields.
- `posted_date` (string, optional) — Date when the invoice was added to the accounting service. This may differ from the invoice creation date.

### ValidationError

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

### ErrorSchema

- `message` (string, required)

### AccountingCustomerRefObject

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

### AccountingReceivableDueDate

Invoice 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.

### ValidationErrorLocItem

### AccountingRefObject

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

## Examples

**Response**

```json
{
  "data": [
    {
      "id": "id",
      "currency": "EUR",
      "currency_rate": 1.1,
      "customer_ref": {
        "id": "120",
        "company_name": "Acme Inc."
      },
      "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",
      "pass_through": {
        "key": "value"
      },
      "posted_date": "posted_date"
    }
  ]
}
```

**SDK Code**

```python
import requests

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

headers = {
    "x-monite-version": "2023-09-01",
    "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/receivables';
const options = {
  method: 'GET',
  headers: {
    'x-monite-version': '2023-09-01',
    '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/receivables"

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

	req.Header.Add("x-monite-version", "2023-09-01")
	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/receivables")

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

request = Net::HTTP::Get.new(url)
request["x-monite-version"] = '2023-09-01'
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/receivables")
  .header("x-monite-version", "2023-09-01")
  .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/receivables', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'x-monite-entity-id' => '9d2b4c8f-2087-4738-ba91-7359683c49a4',
    'x-monite-version' => '2023-09-01',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.sandbox.monite.com/v1/accounting/receivables");
var request = new RestRequest(Method.GET);
request.AddHeader("x-monite-version", "2023-09-01");
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": "2023-09-01",
  "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/receivables")! 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()
```