> This page is for APIs, version E-invoicing.
> For other versions, use one of these documentation indexes:
> - Overview (default): https://avalara.ferndocs.com/api-reference/overview/llms.txt
> - Calculations: https://avalara.ferndocs.com/api-reference/calculations/llms.txt
> - E-invoicing: https://avalara.ferndocs.com/api-reference/e-invoicing/llms.txt
> - Brazil: https://avalara.ferndocs.com/api-reference/brazil/llms.txt
> - Returns: https://avalara.ferndocs.com/api-reference/returns/llms.txt
> - Shared service: https://avalara.ferndocs.com/api-reference/shared-service/llms.txt
> - 1099 & W-9: https://avalara.ferndocs.com/api-reference/1099-w9/llms.txt
> - Tax registrations & business licenses: https://avalara.ferndocs.com/api-reference/tax-registrations/llms.txt
> - ECM: https://avalara.ferndocs.com/api-reference/ecm/llms.txt
> - Cross-Border: https://avalara.ferndocs.com/api-reference/cross-border/llms.txt

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

# List country mandates that are supported by the Avalara E-Invoicing platform

GET https://api.sbx.avalara.com/einvoicing/mandates

> **Access control:** this endpoint is available to users with the `everyone` role.

This endpoint offers a list of country mandates supported by the Avalara E-Invoicing API.

Reference: https://avalara.ferndocs.com/api-reference/e-invoicing/public-reference/get-mandates

## Authentication

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

## Request

### Query parameters

- `$filter` (string, optional) — Filter by field name and value. This filter only supports eq and contains. Refer to [https://developer.avalara.com/avatax/filtering-in-rest/](https://developer.avalara.com/avatax/filtering-in-rest/) for more information on filtering.
- `$top` (integer, optional) — The number of items to include in the result.
- `$skip` (integer, optional) — The number of items to skip in the result.
- `$count` (string, optional) — When set to true, the count of the collection is also returned in the response body.
- `$countOnly` (string, optional) — When set to true, only the count of the collection is returned.

### Headers

- `avalara-version` (string, required) — Header that specifies the API version to use (for example "1.6").
- `X-Avalara-Client` (string, optional) — Optional header for a client identifier string used for diagnostics (for example "Fingerprint").

## Response

### 200

Returns a MandatesResponse object containing the supported country mandates.

- `@recordsetCount` (double, optional) — Total count of results
- `@nextLink` (string, optional, nullable)
- `value` (list of Mandate, optional) — Mandates schema

## Errors

### 401 Unauthorized Error

Unauthorized.

- `any`

### 403 Forbidden Error

Forbidden.

- `Message` (string, optional) — A message that informs the user that they may not access a resource

### 404 Not Found Error

Resource not found

- `error` (string, optional) — The three-digit HTTP error code for a not found error
- `message` (string, optional) — A message about the not found error

### 500 Internal Server Error

Internal server error.

- `error` (string, optional) — A bad request error code
- `message` (string, optional) — A message explaining the bad request error

## Types

### Mandate

- `mandateId` (string, optional) — The `mandateId` is comprised of the country code, mandate type, and the network or regulation type (for example, AU-B2G-PEPPOL). Keep in mind the following when specifying a `mandateId`. - A country can have multiple mandate types (B2C, B2B, B2G). - A entity/company can opt in for multiple mandates. - A `mandateId` is the combination of country + mandate type + network/regulation.
- `countryMandate` (string, optional) — **[LEGACY]** This field is retained for backward compatibility. It is recommended to use `mandateId` instead. The `countryMandate` similar to the `mandateId` is comprised of the country code, mandate type, and the network or regulation type (for example, AU-B2G-PEPPOL).
- `countryCode` (string, optional) — Country code
- `description` (string, optional) — Mandate description
- `supportedByELRAPI` (boolean, optional) — Indicates whether this mandate supported by the ELR API
- `mandateFormat` (string, optional) — Mandate format
- `eInvoicingFlow` (string, optional) — The type of e-invoicing flow for this mandate
- `eInvoicingFlowDocumentationLink` (string, optional) — Link to the documentation for this mandate's e-invoicing flow
- `getInvoiceAvailableMediaType` (list of string, optional) — List of available media types for downloading invoices for this mandate
- `supportsInboundDigitalDocument` (string, optional) — Indicates whether this mandate supports inbound digital documents
- `inputDataFormats` (list of inputDataFormats, optional) — Format and version used when inputting the data
- `outputDataFormats` (list of OutputDataFormats, optional) — Lists the supported output document formats for the country mandate. For countries where specifying an output document format is required (e.g., France), this array will contain the applicable formats. For other countries where output format selection is not necessary, the array will be empty.
- `workflowIds` (list of WorkflowIds, optional) — Workflow ID list
- `supportedDocumentStatuses` (list of SupportedDocumentStatuses, optional) — List of document statuses defined by the mandate.

### inputDataFormats

Format and version used when inputting the data

- `format` (string, optional) — Document format
- `versions` (list of string, optional)

### OutputDataFormats

Format and version used when outputting the data

- `format` (string, optional) — Document format
- `versions` (list of string, optional)

### WorkflowIds

Workflow ID list

- `name` (string, optional) — The name of this workflow
- `description` (string, optional) — Workflow description

### SupportedDocumentStatuses

Represents a document status defined by the mandate.

- `status` (string, optional) — The name of the status (e.g., Approved, Fully Paid).
- `description` (string, optional) — Explanation of what the status means.

## Examples

**Response**

```json
{
  "@recordsetCount": 1,
  "@nextLink": "",
  "value": [
    {
      "mandateId": "AU-B2G-PEPPOL",
      "countryMandate": "AU-B2G-PEPPOL",
      "countryCode": "AU",
      "description": "The mandate supporting B2G eInvoicing in Australia. This function will create a Peppol BIS 3.0 file and sends the invoice to the related recipient via the Peppol network",
      "supportedByELRAPI": "true",
      "mandateFormat": "xml",
      "eInvoicingFlow": "Network",
      "eInvoicingFlowDocumentationLink": "https://documentation.example.com/flows/pt-b2c-pdf",
      "getInvoiceAvailableMediaType": [
        "application/pdf",
        "application/xml"
      ],
      "supportsInboundDigitalDocument": "TRUE",
      "inputDataFormats": [
        {
          "format": "ubl-invoice"
        }
      ],
      "outputDataFormats": [
        {
          "format": "ubl-invoice"
        }
      ],
      "workflowIds": [
        {
          "name": "partner-einvoicing",
          "description": "The standard value for the metadata object in POST /einvoicing/documents "
        }
      ],
      "supportedDocumentStatuses": [
        {
          "status": "Approved",
          "description": "Approved by buyer(C4)"
        },
        {
          "status": "Fully Paid",
          "description": "Payment transmitted to Seller fully from Buyer"
        },
        {
          "status": "Taken Charge",
          "description": "Document has been taken in charge by the recipient (C4)"
        }
      ]
    }
  ]
}
```

**SDK Code**

```python
import requests

url = "https://api.sbx.avalara.com/einvoicing/mandates"

headers = {
    "avalara-version": "1.6",
    "Authorization": "Bearer <token>"
}

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

print(response.json())
```

```javascript
const url = 'https://api.sbx.avalara.com/einvoicing/mandates';
const options = {
  method: 'GET',
  headers: {'avalara-version': '1.6', 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.sbx.avalara.com/einvoicing/mandates"

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

	req.Header.Add("avalara-version", "1.6")
	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.sbx.avalara.com/einvoicing/mandates")

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

request = Net::HTTP::Get.new(url)
request["avalara-version"] = '1.6'
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.sbx.avalara.com/einvoicing/mandates")
  .header("avalara-version", "1.6")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.sbx.avalara.com/einvoicing/mandates', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'avalara-version' => '1.6',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.sbx.avalara.com/einvoicing/mandates");
var request = new RestRequest(Method.GET);
request.AddHeader("avalara-version", "1.6");
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "avalara-version": "1.6",
  "Authorization": "Bearer <token>"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.sbx.avalara.com/einvoicing/mandates")! 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()
```