[Cotlet](https://cotlet.dev/index.md) · [Integrations](https://cotlet.dev/integrations.md) · [How it works](https://cotlet.dev/how-it-works.md) · [Use cases](https://cotlet.dev/use-cases.md) · [Security](https://cotlet.dev/security.md) · [For developers](https://cotlet.dev/for-developers.md) · [For automation agencies](https://cotlet.dev/for-agencies.md) · [Blog](https://cotlet.dev/blog.md) · [API docs](https://cotlet.dev/docs.md) · [Help center](https://cotlet.dev/help.md) · [Changelog](https://cotlet.dev/changelog.md) · [Contact](https://cotlet.dev/contact.md) · [Pricing](https://cotlet.dev/pricing.md) · [Sign up](https://cotlet.dev/signup)

# Acumatica API and MCP server

> Yes. Acumatica has a full contract-based REST API with OAuth 2.0 (checked 14 Oct 2026). It reads and writes bills, invoices, customers and payments and can run actions such as Release. Its built-in MCP server, new in 2026 R2, is read-only and limited to Generic Inquiries that an administrator publishes, so an agent cannot create or release a document through it.

Cloud ERP for mid-sized companies. Financial Management covers accounts payable (bills), accounts receivable (invoices), payments and customers and vendors in one tenant.

## What is the Acumatica API?

Cotlet's Acumatica API exposes 13 endpoints for your own Acumatica account: list customers, list vendors, list invoices, get invoice, list bills, get bill, list bills waiting for payment approval, create customer, create AP bill, create AR invoice, release AP bill, release AR invoice and approve bill for payment. The list_customers endpoint returns customers in your Acumatica tenant with their ID, name and status. Each endpoint takes simple JSON inputs like limit, cursor or reference_nbr and works both as an operation of the acumatica_read or acumatica_write MCP tool for agents and as a REST call for scripts.

- **Category:** [Invoicing & freelance CRM](https://cotlet.dev/integrations/category/invoicing-freelance-crm.md)
- **Endpoints:** 13 (7 read, 6 write)
- **Updated:** 2026-10-23

Yes. Cotlet is a hosted MCP server and REST API for Acumatica with 13 endpoints (7 read, 6 write): you sign in once in your own cloud browser, your AI agent does the work.

## Does Acumatica have an official API?

Yes. Acumatica has a full contract-based REST API with OAuth 2.0 (checked 14 Oct 2026). It reads and writes bills, invoices, customers and payments and can run actions such as Release. Its built-in MCP server, new in 2026 R2, is read-only and limited to Generic Inquiries that an administrator publishes, so an agent cannot create or release a document through it.

| Task | Acumatica official | Cotlet |
|---|---|---|
| List customers and vendors | Yes: Contract-based REST API; the MCP server reads them only through a published inquiry | Yes |
| List invoices and bills by status | Yes: Contract-based REST API with filters | Yes |
| Read one bill or invoice with its lines | Yes: Contract-based REST API | Yes |
| Create an AP bill | Yes: Contract-based REST API; the MCP server cannot write | Yes |
| Create an AR invoice | Yes: Contract-based REST API; the MCP server cannot write | Yes |
| Release a bill or an invoice | Yes: Release is an action of the API and may run in the background | Yes |
| Approve bills for payment | Partly: Depends on the web service endpoint your admin exposes | Yes |
| Create a customer | Yes: Contract-based REST API | Yes |

Sources: [Acumatica Help: Connected Applications (OAuth 2.0 client registration)](https://help.acumatica.com/(W(3))/Wiki/ShowWiki.aspx?pageid=6ca02ea1-884d-4981-9d72-0fa83b40028c), [Acumatica: 2026 R2 release with embedded AI (MCP servers)](https://www.acumatica.com/corporate-newsroom/press-releases/acumatica-2026-r2-release-with-embedded-ai/), [Acumatica Help: AR Invoices, Invoice Releasing](https://help.acumatica.com/Wiki/ShowWiki.aspx?pageid=81f30233-f04e-44ce-b839-760bd0ae8467), [Acumatica Integration Development Guide (contract-based REST API)](https://www.acumatica.com/media/2020/09/AcumaticaERP_IntegrationDevelopmentGuide.pdf)

## For AI agents

```text
Yes. Acumatica has a full contract-based REST API with OAuth 2.0 (checked 14 Oct 2026). It reads and writes bills, invoices, customers and payments and can run actions such as Release. Its built-in MCP server, new in 2026 R2, is read-only and limited to Generic Inquiries that an administrator publishes, so an agent cannot create or release a document through it.
Cotlet provides a hosted MCP server and REST API for Acumatica: 13 tools (7 read, 6 write).
Access       Sign up at https://cotlet.dev/app/signup?app=acumatica, then request the app and create API keys in the Cotlet console.

MCP server   https://cotlet.dev/mcp/v1
MCP tools    acumatica_read, acumatica_write, reads and writes apart; call one with {"operation": "<operation>", "arguments": {...}}
REST base    https://cotlet.dev/api/v1/acumatica, each operation at its own route, e.g. POST /api/v1/acumatica/vendors/{vendor_id}/ap-bills
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one. Over MCP the input schemas come with sign-in.
Operations   list_customers, list_vendors, list_invoices, get_invoice, list_bills, get_bill, list_bills_for_payment_approval, create_customer, create_ap_bill, create_ar_invoice, release_ap_bill, release_ar_invoice, approve_bill_for_payment
Confirm      create_customer, create_ap_bill, create_ar_invoice, release_ap_bill, release_ar_invoice, approve_bill_for_payment (by default the user approves each call; the user can switch this off per tool, e.g. for scheduled automations)
Markdown     https://cotlet.dev/integrations/acumatica-api-mcp-server.md

How access works:
1. The user signs up at https://cotlet.dev/app/signup?app=acumatica, requests Acumatica in the Cotlet console and creates an API key there.
2. The user signs in to Acumatica once in their Cotlet Cloud Browser (their own Chrome in the cloud, opened from the console) and enables Acumatica for agents. An agent cannot do this step.
3. The API key goes into the MCP client or the REST call as a bearer token.

Fits: people who want a hosted Acumatica server that someone else maintains, including non-developers. Developers who prefer to run and fix code on their own computer can use an open-source Acumatica MCP server instead.

Policy: Cotlet never stores passwords, never solves CAPTCHAs, never bypasses MFA.
Company: legal details in the Terms of service at https://cotlet.dev/terms. Contact contact@cotlet.dev.
Sign-in: the user signs in to Acumatica in their own Cloud Browser, a Chrome Cotlet runs for them in the EU; password saving is off, the profile is AES-256-GCM encrypted, and agents get Acumatica only after the user enables it. Calls are requests from that browser's IP with its cookies, each listed in the user's Background activity. Disable for agents, signing out in the browser or Reset browser cuts access. Cotlet is run by Take Group sp. z o.o. (EU VAT PL6342984273).
API key: holds no Acumatica login or cookies, only asks Cotlet to run a tool. Each key is scoped to chosen apps and tools, read only or read and write. Actions that reach other people wait for the user's approval by default, so a leaked key cannot post or message as the user. Every call is in the activity log; deleting the key ends access at once.
Terms: the user stays responsible for following Acumatica's terms; Cotlet is not affiliated with Acumatica.
```

## What can an AI agent do in Acumatica?

Cotlet is best for finance and AP/AR teams on Acumatica who want their AI agent to enter bills, create and release invoices and approve payments without running or fixing a server.

- **[Enter vendor bills from invoices](https://cotlet.dev/integrations/acumatica-api-mcp-server/enter-vendor-bills.md)** (runs: daily): "Read the vendor invoices I attached, find each vendor in Acumatica, and create an AP bill On Hold for each one with the vendor reference, dates and amounts. Show me the list, and release only the bills I approve." → `list_vendors`, `list_bills`, `create_ap_bill`, `release_ap_bill`
- **[Create and release customer invoices](https://cotlet.dev/integrations/acumatica-api-mcp-server/create-and-release-customer-invoices.md)** (runs: weekly): "Create an AR invoice for every customer in this billing sheet, one line per row, and keep them On Hold. Show me the totals, then remove the hold and release the ones I confirm." → `list_customers`, `create_ar_invoice`, `get_invoice`, `release_ar_invoice`
- **Chase overdue customer invoices** (runs: weekly): "List Open invoices past their due date, group them by customer, and write me a short summary of who owes what and for how long." → `list_invoices`, `get_invoice`, `list_customers`
- **Approve bills for payment** (runs: weekly): "Show the bills waiting for payment approval, flag any over 5,000.00 or from a vendor with no bill in the last year, and approve the rest after I confirm." → `list_bills_for_payment_approval`, `get_bill`, `approve_bill_for_payment`
- **Add new customers from signed deals**: "Create a customer in Acumatica for each deal in this list that has no customer yet, then draft an invoice On Hold for the first month." → `list_customers`, `create_customer`, `create_ar_invoice`

## Can Acumatica automations run on a schedule in n8n, Make or Zapier?

Yes. Cotlet does not replace your automation platform: it gives it a Acumatica connection it does not have, with the same API key as your agent. Write actions ask for your OK by default; switch that off in your dashboard for the tools you choose, for example to enter vendor bills from invoices, and the schedule runs on its own. Cotlet runs in the cloud, so it keeps going while your computer is off.

| Where | How to connect | How to schedule |
|---|---|---|
| Your AI agent | Add https://cotlet.dev/mcp/v1 with your API key. | A scheduled agent run, for example a Claude Code routine. |
| n8n | MCP Client node with https://cotlet.dev/mcp/v1, or an HTTP Request node with the endpoint's method and URL, such as GET https://cotlet.dev/api/v1/acumatica/vendors. | Schedule Trigger node. |
| Make | HTTP module: the endpoint's method and URL with an Authorization: Bearer header, and a JSON body for POST, PUT and PATCH. | Scenario schedule. |
| Zapier | Webhooks by Zapier, Custom Request: the same method, URL, header and body. | Schedule by Zapier trigger. |
| Your own script | GET https://cotlet.dev/api/v1/acumatica/vendors with your API key. | cron or GitHub Actions. |

## Tools

**For AI agents:** Every endpoint and its schema is public. The 13 endpoints on this page, with parameters and example responses, can be listed without an account. Calling one returns 401 without an API key and 403 while the key has no access to Acumatica.

### list_customers

Customers in your Acumatica tenant with their ID, name and status. Access: read. REST: `GET /api/v1/acumatica/customers`. MCP: `acumatica_read → list_customers`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `search` | string | no | Part of the customer name. |
| `status` | string | no | Status as Acumatica shows it, for example Active. |
| `limit` | integer | no | Rows per page. Default: 50. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists customers, filtered by a name search or by status. Use customer_id from each item in create_ar_invoice and list_invoices. The search matches the name as Acumatica shows it, so a short fragment can return several customers and your agent should ask when more than one fits.

Example response:

```json
{
  "customers": [
    {
      "customer_id": "C000045",
      "name": "Harbor Dental Group",
      "status": "Active"
    },
    {
      "customer_id": "C000051",
      "name": "Lakeside Studio",
      "status": "Active"
    }
  ],
  "next_cursor": null
}
```

### list_vendors

Vendors in your Acumatica tenant with their ID, name and status. Access: read. REST: `GET /api/v1/acumatica/vendors`. MCP: `acumatica_read → list_vendors`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `search` | string | no | Part of the vendor name. |
| `status` | string | no | Status as Acumatica shows it, for example Active. |
| `limit` | integer | no | Rows per page. Default: 50. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists vendors, filtered by a name search or by status. Use vendor_id from each item in create_ap_bill and list_bills. The search matches the vendor name as Acumatica shows it.

Example response:

```json
{
  "vendors": [
    {
      "vendor_id": "V000123",
      "name": "Northwind Office Supply",
      "status": "Active"
    },
    {
      "vendor_id": "V000130",
      "name": "Delta Freight",
      "status": "Active"
    }
  ],
  "next_cursor": null
}
```

### list_invoices

AR invoices with customer, dates, amount, balance and status. Open invoices by default. Access: read. REST: `GET /api/v1/acumatica/invoices`. MCP: `acumatica_read → list_invoices`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | enum | no | On Hold, Balanced or Open. Default: Open. |
| `customer_id` | string | no | Only invoices of this customer. |
| `due_before` | date | no | Only invoices due before this date. |
| `limit` | integer | no | Rows per page. Default: 50. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists AR invoices from Invoices and Memos. Filter by status (On Hold, Balanced or Open), by customer and by due date. Open invoices are released documents with a balance; overdue ones are those with due_before set to today. Pass reference_nbr to get_invoice for the lines.

Example response:

```json
{
  "invoices": [
    {
      "reference_nbr": "002214",
      "customer_id": "C000045",
      "customer": "Harbor Dental Group",
      "date": "2026-09-01",
      "due_date": "2026-10-01",
      "amount": 3150,
      "balance": 3150,
      "status": "Open"
    }
  ],
  "next_cursor": null
}
```

### get_invoice

One AR invoice with its lines, total, balance and status. Access: read. REST: `GET /api/v1/acumatica/invoice`. MCP: `acumatica_read → get_invoice`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `reference_nbr` | string | yes | Reference number of the document, from list_invoices or list_bills. |

Returns one AR invoice with every line (description, quantity, unit price, amount), the total and the status. Use it to check an invoice you just created before releasing it. The total is the sum of the lines.

Example response:

```json
{
  "reference_nbr": "002214",
  "customer_id": "C000045",
  "status": "Balanced",
  "date": "2026-10-31",
  "lines": [
    {
      "description": "Hosting, October",
      "quantity": 1,
      "unit_price": 2400,
      "amount": 2400
    },
    {
      "description": "Support hours",
      "quantity": 5,
      "unit_price": 150,
      "amount": 750
    }
  ],
  "total": 3150
}
```

### list_bills

AP bills with vendor, vendor reference, dates, amount and status. Access: read. REST: `GET /api/v1/acumatica/bills`. MCP: `acumatica_read → list_bills`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | enum | no | On Hold, Pending Approval, Balanced or Open. Default: all. |
| `vendor_id` | string | no | Only bills of this vendor. |
| `vendor_ref` | string | no | Only bills with this vendor reference. |
| `limit` | integer | no | Rows per page. Default: 50. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists AP bills from Bills and Adjustments. Filter by status (On Hold, Pending Approval, Balanced or Open), by vendor and by vendor reference. Use the vendor reference filter before creating a bill, to avoid entering the same vendor invoice twice.

Example response:

```json
{
  "bills": [
    {
      "reference_nbr": "004790",
      "vendor_id": "V000123",
      "vendor": "Northwind Office Supply",
      "vendor_ref": "INV-20391",
      "date": "2026-09-28",
      "due_date": "2026-10-28",
      "amount": 610,
      "status": "Open"
    }
  ],
  "next_cursor": null
}
```

### get_bill

One AP bill with its lines, total and status. Access: read. REST: `GET /api/v1/acumatica/bill`. MCP: `acumatica_read → get_bill`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `reference_nbr` | string | yes | Reference number of the document, from list_invoices or list_bills. |

Returns one AP bill with every line (description, amount, account), the total and the status. Use it before approving or releasing a bill. The total is the sum of the lines.

Example response:

```json
{
  "reference_nbr": "004812",
  "vendor_id": "V000123",
  "vendor_ref": "INV-20418",
  "status": "On Hold",
  "lines": [
    {
      "description": "Printer paper, 40 boxes",
      "amount": 960,
      "account": "60100"
    },
    {
      "description": "Toner cartridges",
      "amount": 280,
      "account": "60100"
    }
  ],
  "total": 1240
}
```

### list_bills_for_payment_approval

Open bills that are waiting to be approved for payment, with vendor, due date and amount. Access: read. REST: `GET /api/v1/acumatica/bills-for-payment-approvals`. MCP: `acumatica_read → list_bills_for_payment_approval`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `due_before` | date | no | Only bills due before this date. |
| `limit` | integer | no | Rows per page. Default: 50. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists the bills that appear on the Approve Bills for Payment form, with vendor, due date and amount, so your agent can sort them by due date or amount. Which bills appear depends on how your company set up payment approval. Pass reference_nbr to get_bill for the lines.

Example response:

```json
{
  "bills": [
    {
      "reference_nbr": "004790",
      "vendor": "Northwind Office Supply",
      "due_date": "2026-10-28",
      "amount": 610
    },
    {
      "reference_nbr": "004813",
      "vendor": "Delta Freight",
      "due_date": "2026-11-05",
      "amount": 3075.5
    }
  ],
  "next_cursor": null
}
```

### create_customer

Create a customer with a name and a billing email. Access: write, asks the user first. REST: `POST /api/v1/acumatica/customers`. MCP: `acumatica_write → create_customer`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `name` | string | yes | Customer name. |
| `email` | string | no | Billing email address. |

Creates a customer and returns its customer_id for create_ar_invoice. The call checks the name against existing customers first and stops on an exact match, so you do not get a duplicate. Other customer settings stay at the defaults your Acumatica setup applies. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "customer_id": "C000058",
  "name": "Pine Corner Bakery",
  "status": "Active"
}
```

### create_ap_bill

Create an AP bill for a vendor with one or more lines. On Hold by default. Access: write, asks the user first. REST: `POST /api/v1/acumatica/vendors/{vendor_id}/ap-bills`. MCP: `acumatica_write → create_ap_bill`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `vendor_id` | string | yes | Vendor ID as shown in Acumatica, from list_vendors. |
| `vendor_ref` | string | yes | The vendor's own invoice number. |
| `date` | date | yes | Document date. |
| `due_date` | date | no | Due date. Default: set by the vendor terms in Acumatica. |
| `hold` | boolean | no | true saves the document On Hold so you can review it. false saves it as Balanced, ready to release. Default: true. |
| `lines` | array | yes | Objects with description (string), amount (number) and account (string, an account number from your chart of accounts). |

Creates a bill in Bills and Adjustments for one vendor. With hold set to true, the default, the bill is saved On Hold and cannot be released until someone removes the hold. The total is the sum of the lines. Taxes and approvals follow your Acumatica setup, so a bill can come back Pending Approval. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "reference_nbr": "004812",
  "vendor_id": "V000123",
  "vendor_ref": "INV-20418",
  "status": "On Hold",
  "total": 1240
}
```

### create_ar_invoice

Create an AR invoice for a customer with one or more lines. On Hold by default. Access: write, asks the user first. REST: `POST /api/v1/acumatica/customers/{customer_id}/ar-invoices`. MCP: `acumatica_write → create_ar_invoice`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `customer_id` | string | yes | Customer ID as shown in Acumatica, from list_customers. |
| `date` | date | yes | Document date. |
| `hold` | boolean | no | true saves the document On Hold so you can review it. false saves it as Balanced, ready to release. Default: true. |
| `lines` | array | yes | Objects with description (string), quantity (number) and unit_price (number). |

Creates an invoice in Invoices and Memos for one customer. With hold set to true, the default, the invoice is saved On Hold; with false it is saved Balanced and can be released. The total is the sum of quantity times unit price over the lines. Taxes follow your Acumatica setup. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "reference_nbr": "002231",
  "customer_id": "C000045",
  "status": "Balanced",
  "total": 3150
}
```

### release_ap_bill

Release a bill so it becomes Open and posts to the ledger as your setup says. Access: write, asks the user first. REST: `POST /api/v1/acumatica/ap-bill/release`. MCP: `acumatica_write → release_ap_bill`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `reference_nbr` | string | yes | Reference number of the document, from list_invoices or list_bills. |
| `remove_hold` | boolean | no | true removes the hold before releasing. Default: false. |

Runs Release on one AP bill. A bill On Hold cannot be released, so set remove_hold to true to make it Balanced first. A released bill is Open and cannot be edited or deleted; it is corrected by a reversal. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "reference_nbr": "004812",
  "status": "Open"
}
```

### release_ar_invoice

Release an invoice so it becomes Open, raises the customer balance and creates a ledger batch. Access: write, asks the user first. REST: `POST /api/v1/acumatica/ar-invoice/release`. MCP: `acumatica_write → release_ar_invoice`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `reference_nbr` | string | yes | Reference number of the document, from list_invoices or list_bills. |
| `remove_hold` | boolean | no | true removes the hold before releasing. Default: false. |

Runs Release on one AR invoice. Only a Balanced invoice can be released, so set remove_hold to true for one that is On Hold. Release makes the invoice Open, increases the customer balance and generates a general ledger batch. The release can run in the background, and the call returns the status when it ends. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "reference_nbr": "002231",
  "status": "Open"
}
```

### approve_bill_for_payment

Approve an open bill for payment on the Approve Bills for Payment form. Access: write, asks the user first. REST: `POST /api/v1/acumatica/bill-for-payment/approve`. MCP: `acumatica_write → approve_bill_for_payment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `reference_nbr` | string | yes | Reference number of the document, from list_invoices or list_bills. |

Approves one bill on the Approve Bills for Payment form so it can be paid. The call fails with a permission error for a user without access to that form. Approving does not pay the bill. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "reference_nbr": "004813",
  "approved_for_payment": true
}
```

## How do I connect Acumatica to Claude Code, Codex or Cursor?

Connecting Acumatica takes three steps: sign up, sign in to Acumatica once in your Cloud Browser and enable it for agents, then add one MCP server or call the REST API with the same key.

### Connect Acumatica to your agent.

1. **Create an account** Sign up and add Acumatica in the console. Your API key is there too.

2. **Sign in to Acumatica in your Cloud Browser** Open your Cloud Browser in the console: your own Chrome in the cloud. Sign in to Acumatica there yourself, the way you always do, then press Enable for agents, read only or read and write. We never save your password, and your agent keeps working even when your computer is off.

3. **Add Cotlet to your agent** Paste the snippet for your client. The same server and key serve every app you connect, so you do this once.

   Claude Code:

```
claude mcp add --transport http cotlet \
  https://cotlet.dev/mcp/v1 \
  --header "Authorization: Bearer $COTLET_API_KEY"
```

   Cursor:

```
{
  "mcpServers": {
    "cotlet": {
      "url": "https://cotlet.dev/mcp/v1",
      "headers": {
        "Authorization": "Bearer ${COTLET_API_KEY}"
      }
    }
  }
}
```

   Codex:

```
# ~/.codex/config.toml
[mcp_servers.cotlet]
url = "https://cotlet.dev/mcp/v1"
bearer_token_env_var = "COTLET_API_KEY"
```

4. **Ask your agent** Ask in plain words. Your agent finds the Acumatica tools on the server and calls them for you; anything that reaches other people waits for your OK unless you switch that off for a tool.

```
Read the vendor invoices I attached, find each vendor in Acumatica, and create an AP bill On Hold for each one with the vendor reference, dates and amounts. Show me the list, and release only the bills I approve.
```

### Call Acumatica from your scripts.

1. **Export your API key** Your scripts use the same API key as your agent. Keep it in an environment variable, never in your code.

```
export COTLET_API_KEY="cotlet_..."
```

2. **Call a tool** Every tool is an endpoint under /api/v1/acumatica with its own method and path, listed with the endpoints above. Path parameters go in the URL; the other parameters go in the query for GET and DELETE and in a JSON body otherwise.

```
curl -X POST https://cotlet.dev/api/v1/acumatica/vendors/V000123/ap-bills \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"vendor_ref":"INV-20418","date":"2026-10-12","due_date":"2026-11-11","hold":true,"lines":[{"description":"Printer paper, 40 boxes","amount":960,"account":"60100"},{"description":"Toner cartridges","amount":280,"account":"60100"}]}'
```

3. **Read the result** You get plain JSON back, ready for your script. A failed call costs nothing.

```
{
  "reference_nbr": "004812",
  "vendor_id": "V000123",
  "vendor_ref": "INV-20418",
  "status": "On Hold",
  "total": 1240
}
```

## Why use Cotlet for Acumatica?

**Built for agents**

- One MCP server for every app you connect.
- The same tools as a REST API for scripts and cron jobs.
- Works with Claude Code, Codex and Cursor.

**Your login stays yours**

- You sign in to Acumatica yourself, in your own Cloud Browser. We never save your password; the profile is encrypted with AES-256-GCM, the cipher 1Password uses.
- A+ on Qualys SSL Labs, securityheaders.com and Mozilla Observatory.
- The model never sees a login.
- No stored passwords, no CAPTCHA solving, no MFA bypass.

**You stay in control**

- Scope each API key: its apps, its tools, read only or read and write.
- Anything that reaches other people waits for your OK, so a leaked key cannot post or message as you.
- Every background request listed in your Background activity. Disable for agents in one click.

**Kept working for you**

- We test every integration every 6 hours.
- When Acumatica changes, the tool pauses until we fix it.
- Failed calls cost nothing.

## Is it safe to connect Acumatica to Cotlet?

Yes. You sign in to Acumatica yourself, in your own Cloud Browser, and we never save your password. Your agents only get Acumatica once you enable it, and every background request is listed. The browser profile is stored encrypted with AES-256-GCM, the same cipher 1Password uses for its vaults and Apple for iCloud Keychain. Independent public scanners grade cotlet.dev A+ and find it clean; click a result to rerun it yourself.

- **A+ on Qualys SSL Labs**: Encryption in transit: TLS setup and certificates, on all four server addresses. [Live result](https://www.ssllabs.com/ssltest/analyze.html?d=cotlet.dev)
- **A+ on securityheaders.com**: Browser protections sent with every page, all six headers present. [Live result](https://securityheaders.com/?q=cotlet.dev&followRedirects=on)
- **A+ on Mozilla Observatory**: Mozilla's web security baseline: score 120 of 100, 12 of 12 tests passed. [Live result](https://developer.mozilla.org/en-US/observatory/analyze?host=cotlet.dev)
- **Clean on Sucuri SiteCheck**: No malware, spam or defacement, and not on any of 9 blocklists, Google Safe Browsing included. [Live result](https://sitecheck.sucuri.net/results/cotlet.dev)

[How Cotlet protects your access](https://cotlet.dev/security.md)

### Common concerns

**Who runs Cotlet?**

Cotlet is run by Take Group, a Polish software company working since 2019. Take Group runs about 3,200 websites on its own systems and has its own DevOps team for infrastructure security. We built and used integrations like this inside the company for years before opening them as Cotlet.

**Is this an official Acumatica integration?**

No, Cotlet is independent of Acumatica. Acumatica's own API is too limited for this work. Cotlet works through your own Acumatica account, the way you use Acumatica in the browser, so you need no partner approval and no developer setup.

**What about client data and GDPR?**

Cotlet is run from the EU and follows the GDPR. Cloud Browsers run in Finland, a Tier 1 country in the ITU Global Cybersecurity Index 2024. Data passes through a call and is not kept after it.

**Can I start with read only?**

Yes. Enable the app for agents as read only, or make the API key read only, and anything that reaches other people waits for your OK unless you switch that off per tool.

**Is it reliable?**

Every Cotlet service is checked every 3 minutes from Europe, North America, Asia and Australia. The live results and any outage are public at status.cotlet.dev.

**How do I stop?**

Press Disable for agents next to Acumatica in your console: your agents lose access at once and you stay signed in. Signing out of Acumatica in the browser works too, and Reset browser deletes the whole profile.

## Is there a Acumatica MCP server on GitHub?

Yes. Open-source Acumatica MCP servers exist on GitHub and in Acumatica's community forum, usually maintained by one person. You install one yourself, register an OAuth Connected Application on your tenant for it, and fix it when your version changes. The official route is the REST API, which your developer calls with tokens per company. Cotlet hosts the same tools for you behind one key and one sign-in, and our team keeps them working.

|  | GitHub MCP server | Cotlet |
|---|---|---|
| Setup | Clone the repo, register a Connected Application and an access role in Acumatica, configure the server for each MCP client | Sign up, sign in to Acumatica once, add one MCP server or API key |
| When Acumatica changes | It breaks until you or the maintainer fix it, for example after an upgrade to a new release | Our team tests it daily and fixes it for you; failed calls are free |
| Your Acumatica access | OAuth credentials in a file or environment on your computer, readable by any program you run | Signed in inside your own Cloud Browser in the EU, profile encrypted, only for the apps you enable, disabled for agents in one click |
| When access expires | Tools fail until you refresh the token or sign in again by hand | Your Cloud Browser keeps you signed in; if Acumatica signs you out, your agent gets a link to sign in again |
| Upkeep | You update, monitor and debug it yourself | Nothing to host or update |
| Where it runs | Your computer, while it is on | Hosted: Claude Code, Codex, Cursor, n8n and scripts, also on a schedule |
| Price | Free, paid for with your time | Free 7-day trial, then pay-as-you-go credit packs, no subscription |

### Which one fits you

**Pick Cotlet if**

- you are not a developer, or you do not want to maintain a server
- you need it to keep working when Acumatica changes, without checking it yourself
- your agent or a script should run it on a schedule, also while your computer is off

**Pick an open-source server if**

- you are comfortable installing, updating and fixing it yourself
- you want your sign-in to stay on your own computer
- you only need it now and then, from one MCP client

## How much does the Acumatica API cost?

Free 7-day trial with 2,000 credits, no card needed. After that, the Acumatica API is pay as you go with no limit on apps: Credit packs from $29 for 5,000 credits, one-time, no subscription. A successful call uses 10 credits (about $0.04 to $0.06), your Cloud Browser uses 50 credits a day while it has an app enabled for agents, however many apps that is, and an agent driving the browser itself uses 5 credits a minute. Credit packs stay valid for 12 months and stack, so unused credits carry over.

| Credits | Price, one time | Calls at 10 credits | Per 1,000 credits |
|---|---|---|---|
| 5,000 | $29 | 500 | $5.80 |
| 15,000 | $79 | 1,500 | $5.27 |
| 32,000 | $149 | 3,200 | $4.66 |
| 60,000 | $249 | 6,000 | $4.15 |

Only successful calls use credits; failed calls and timeouts cost nothing. At a balance of 0 calls pause, never a surprise charge. Authenticate with the `Authorization: Bearer` header. [See full pricing](https://cotlet.dev/pricing.md)

## How Cotlet holds your access

Cotlet hosts MCP servers and REST APIs for apps with no usable API. Your agent works in your own Acumatica account.

- **Company details:** Cotlet is run by Take Group sp. z o.o., a company registered in Poland. Its full address and registration numbers are in the Terms of service. [Terms of service](https://cotlet.dev/terms)
- **Your sign-in:** You sign in to Acumatica yourself, in your own Cloud Browser: a Chrome we run for you in the EU, one per app. We never save your password (password saving is off), the profile is stored encrypted with AES-256-GCM, and your agents get Acumatica only after you enable it. When Acumatica signs you out, your agent gives you a link to sign in again. [Security](https://cotlet.dev/security.md)
- **Revoking access:** Press Disable for agents next to Acumatica, sign out of Acumatica in your Cloud Browser, or reset the browser. Every background request is listed in your Background activity. Actions that reach other people wait for your OK unless you switch that off per tool.
- **What we never do:** Store passwords, solve CAPTCHAs or bypass MFA.
- **Acumatica's terms:** You use your own Acumatica account and stay responsible for following Acumatica's terms. Cotlet is independent and not affiliated with Acumatica. [Terms](https://cotlet.dev/terms)
- **Contact:** Questions about the company, security or an app: [contact@cotlet.dev](mailto:contact@cotlet.dev)

## Frequently asked questions

**How do I get access?**

Sign up free, open Acumatica in the console and press Request access. Then you create your API key and connect Acumatica there.

**Do I need to be technical?**

No. You sign in to Acumatica once in your Cloud Browser, a normal Chrome you open from the console, and paste one command into your agent, or one URL into n8n. Your agent can walk you through it. There is no server to install, update or fix.

**Is it safe to connect Acumatica to Cotlet?**

Yes. You sign in to Acumatica yourself, in your own Cloud Browser in the EU, and we never save your password. Your agents only get Acumatica once you enable it, every background request is listed, and the browser profile is stored encrypted with AES-256-GCM, the cipher 1Password uses for its vaults. The AI model never sees a login, posts and messages wait for your OK, and Disable for agents cuts access in one click. Independent scanners grade cotlet.dev A+ on Qualys SSL Labs, securityheaders.com and Mozilla Observatory; live results are on https://cotlet.dev/security.

**Is a hosted server safer than a local one? My Acumatica sign-in would leave my computer.**

On Cotlet you sign in inside your own Cloud Browser, which only you open, and its profile is stored encrypted with AES-256-GCM in the EU. Agents get only the apps you enable, and every background request is listed. A local server keeps your Acumatica cookie in a plain file on your computer, readable by any program you run, and stops when your computer is off.

**Why does Cotlet send requests instead of clicking in my browser?**

To be fast, Cotlet doesn't click through Acumatica's pages. It sends the same requests your browser would, from your browser's IP with its cookies, without opening a window. Acumatica sees the same browser and IP you signed in with, and every request is listed in your Background activity.

**What if someone gets my Cotlet API key?**

The key holds no Acumatica login or cookies, it only asks Cotlet to run a tool. It can call only the apps and tools you gave it, and a read-only key changes nothing. Anything that reaches other people, like posts, comments or messages, waits for your OK in the dashboard by default, so a leaked key cannot post or message as you. When you switch approval off for a scheduled job, give that job its own key limited to that one tool. Every call is in your activity log, and deleting the key ends access at once.

**Why a signed-in browser and not OAuth, like other integration platforms?**

Acumatica offers no OAuth token you can simply grant for these tools: its official API leaves them out or needs a developer app, a plan or an approval first (see the official API section above). That is why Cotlet sets the limits itself: per key, per tool, with your approval before anything reaches other people. Cotlet is run by Take Group sp. z o.o., an EU company (VAT PL6342984273).

**Do I need to register an OAuth application in Acumatica?**

No. Cotlet works from your own Acumatica sign-in and does not use a Connected Application. Acumatica documents the Connected Applications form for registering OAuth 2.0 clients, which your own code or an open-source server would need.

**Can my agent release a bill that is On Hold?**

Yes, with remove_hold set to true, if your user is allowed to do it in Acumatica. Acumatica itself does not release a document On Hold, and a released bill is Open and cannot be deleted, so by default you confirm each release.

**Can my agent post or send messages in Acumatica without asking me?**

No. Every call to create_customer, create_ap_bill, create_ar_invoice, release_ap_bill, release_ar_invoice or approve_bill_for_payment waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals.

**Can I use the Acumatica API in n8n?**

Yes. Add https://cotlet.dev/mcp/v1 with your API key in n8n's MCP Client node, or call its endpoints under https://cotlet.dev/api/v1/acumatica from the HTTP Request node.

---

Give your AI agents your signed-in browser.

**Product:** [Integrations](https://cotlet.dev/integrations.md) · [Use cases](https://cotlet.dev/use-cases.md) · [How it works](https://cotlet.dev/how-it-works.md) · [Pricing](https://cotlet.dev/pricing.md) · [Security](https://cotlet.dev/security.md)

**Resources:** [Blog](https://cotlet.dev/blog.md) · [API docs](https://cotlet.dev/docs.md) · [Help center](https://cotlet.dev/help.md) · [Changelog](https://cotlet.dev/changelog.md) · [GitHub](https://github.com/cotletdev/cotlet)

**Solutions:** [For developers](https://cotlet.dev/for-developers.md) · [For automation agencies](https://cotlet.dev/for-agencies.md)

**Company:** [About](https://cotlet.dev/about.md) · [AI info: company facts](https://cotlet.dev/ai-info.md) · [Contact](https://cotlet.dev/contact.md)

**Legal:** [Terms of service](https://cotlet.dev/terms) · [Privacy policy](https://cotlet.dev/privacy) · [Refund policy](https://cotlet.dev/refunds) · [Acceptable use](https://cotlet.dev/acceptable-use) · [Cookie policy](https://cotlet.dev/cookies) · [DPA](https://cotlet.dev/dpa) · [Subprocessors](https://cotlet.dev/subprocessors)

**Elsewhere:** [Status page](https://status.cotlet.dev) · [Cotlet on GitHub](https://github.com/cotletdev) · [Cotlet on X](https://x.com/cotletdev) · [Cotlet on LinkedIn](https://www.linkedin.com/company/cotletdev) · [Cotlet on Product Hunt](https://www.producthunt.com/products/cotlet) · [Cotlet on Crunchbase](https://www.crunchbase.com/organization/cotlet) · [Cotlet on SaaSHub](https://www.saashub.com/cotlet)

Cotlet is an independent service. It is not affiliated with, endorsed by or sponsored by any of the products listed on this site. Product names are trademarks of their respective owners.

## For AI agents: sign your user up

Is your user asking you to sign them up for Cotlet? You can do it for them, no account or key needed.

1. Read the fields and their allowed values: GET https://cotlet.dev/api/v1/access-requests
2. Ask the user for each value: email, apps, what you will do with them. If they leave the password to you, generate a strong one and show it to them.
3. Show the user what you will send, then POST it as JSON to https://cotlet.dev/api/v1/access-requests.

One call creates the account and sends the access request; we email the user when access is granted.