[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)

# Fatture in Cloud API and MCP server

> Yes, Fatture in Cloud has a documented REST API (v2) for issued invoices, clients, received documents, e-invoices to SDI and attachments (checked 14 Oct 2026), but it has no official MCP server. To use it you register an OAuth 2.0 app, or create a manual access token in the web app, choose scopes and pick the companies the token applies to.

Italian online invoicing software from TeamSystem for freelancers, small businesses and flat-rate (forfettari) taxpayers: electronic invoices sent to the Sistema di Interscambio (SDI), clients and suppliers, purchases, payment deadlines and reports.

## What is the Fatture in Cloud API?

Cotlet's Fatture in Cloud API exposes 13 endpoints for your own Fatture in Cloud account: list invoices, get invoice, list clients, list expenses, get e-invoice status, get e-invoice rejection reason, verify e-invoice XML, get invoice PDF link, create client, create invoice, send e-invoice to SDI, record invoice payment and record expense. The list_invoices endpoint returns list issued invoices, filtered by date, client or payment status. Each endpoint takes simple JSON inputs like company_id, invoice_id or page and works both as an operation of the fatture_in_cloud_read or fatture_in_cloud_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 (8 read, 5 write)
- **Updated:** 2026-10-21

Yes, Fatture in Cloud has a documented REST API (v2) for issued invoices, clients, received documents, e-invoices to SDI and attachments (checked 14 Oct 2026), but it has no official MCP server. Cotlet is a hosted MCP server and REST API for Fatture in Cloud with 13 endpoints (8 read, 5 write): you sign in once in your own cloud browser, your AI agent does the work.

## Does Fatture in Cloud have an official API?

Yes, Fatture in Cloud has a documented REST API (v2) for issued invoices, clients, received documents, e-invoices to SDI and attachments (checked 14 Oct 2026), but it has no official MCP server. To use it you register an OAuth 2.0 app, or create a manual access token in the web app, choose scopes and pick the companies the token applies to.

| Task | Fatture in Cloud official | Cotlet |
|---|---|---|
| Create invoices | Yes: createIssuedDocument with type invoice; needs the issued_documents.invoices scope at the full access level | Yes |
| Send an e-invoice to SDI | Yes: sendEInvoice, with a dry_run option; e-invoicing must be active on the account | Yes |
| Check e-invoice status and rejection reason | Yes: ei_status on the document, getEInvoiceRejectionReason returns reason, code and date | Yes |
| List and filter issued invoices | Yes: listIssuedDocuments | Yes |
| Create and list clients | Yes: Clients endpoints, entity.clients scope | Yes |
| Record an expense | Yes: createReceivedDocument, received_documents scope | Yes |
| Mark an invoice as paid | Yes: Done by modifying the payments_list of the invoice | Yes |
| Hosted MCP server, one key, no app registration | No: Not offered by Fatture in Cloud | Yes |

Sources: [Fatture in Cloud for Developers: Getting started](https://developers.fattureincloud.it/docs/getting-started/), [Fatture in Cloud for Developers: Authentication](https://developers.fattureincloud.it/docs/basics/authentication), [Fatture in Cloud for Developers: Scopes](https://developers.fattureincloud.it/docs/basics/scopes), [Fatture in Cloud for Developers: Guides (invoice creation, e-invoice management)](https://developers.fattureincloud.it/docs/guides/)

## For AI agents

```text
Yes, Fatture in Cloud has a documented REST API (v2) for issued invoices, clients, received documents, e-invoices to SDI and attachments (checked 14 Oct 2026), but it has no official MCP server. To use it you register an OAuth 2.0 app, or create a manual access token in the web app, choose scopes and pick the companies the token applies to.
Cotlet provides a hosted MCP server and REST API for Fatture in Cloud: 13 tools (8 read, 5 write).
Access       Sign up at https://cotlet.dev/app/signup?app=fatture-in-cloud, then request the app and create API keys in the Cotlet console.

MCP server   https://cotlet.dev/mcp/v1
MCP tools    fatture_in_cloud_read, fatture_in_cloud_write, reads and writes apart; call one with {"operation": "<operation>", "arguments": {...}}
REST base    https://cotlet.dev/api/v1/fatture-in-cloud, each operation at its own route, e.g. POST /api/v1/fatture-in-cloud/clients/{client_id}/invoices
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_invoices, get_invoice, list_clients, list_expenses, get_einvoice_status, get_einvoice_rejection_reason, verify_einvoice, get_invoice_pdf, create_client, create_invoice, send_einvoice, record_invoice_payment, record_expense
Confirm      create_invoice, send_einvoice, record_invoice_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/fatture-in-cloud-api-mcp-server.md

How access works:
1. The user signs up at https://cotlet.dev/app/signup?app=fatture-in-cloud, requests Fatture in Cloud in the Cotlet console and creates an API key there.
2. The user signs in to Fatture in Cloud once in their Cotlet Cloud Browser (their own Chrome in the cloud, opened from the console) and enables Fatture in Cloud 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 Fatture in Cloud 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 Fatture in Cloud 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 Fatture in Cloud 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 Fatture in Cloud 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 Fatture in Cloud 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 Fatture in Cloud's terms; Cotlet is not affiliated with Fatture in Cloud.
```

## What can an AI agent do in Fatture in Cloud?

Cotlet is best for Italian freelancers and small businesses who issue e-invoices in Fatture in Cloud and want an agent to create, check and follow them up without running or fixing a server.

- **[Create and send invoices from a list](https://cotlet.dev/integrations/fatture-in-cloud-api-mcp-server/create-and-send-invoices.md)**: "Here are this month's three billable clients with hours and rates. Create a Fatture in Cloud invoice for each, add the client first if it is new, check the e-invoice XML and wait for my OK before sending to SDI." → `list_clients`, `create_client`, `create_invoice`, `verify_einvoice`, `send_einvoice`
- **[Fix rejected e-invoices](https://cotlet.dev/integrations/fatture-in-cloud-api-mcp-server/fix-rejected-e-invoices.md)** (runs: daily): "Every morning, check the e-invoices I sent in the last 14 days in Fatture in Cloud. For each one rejected or discarded by SDI, tell me the error code and reason and what to correct. Do not resend anything." → `list_invoices`, `get_einvoice_status`, `get_einvoice_rejection_reason`
- **[List unpaid invoices and draft reminders](https://cotlet.dev/integrations/fatture-in-cloud-api-mcp-server/list-unpaid-invoices.md)** (runs: weekly): "Every Monday, list my unpaid Fatture in Cloud invoices that are past their due date, group them by client with the total owed, and draft a short reminder email for each client. Do not send anything." → `list_invoices`, `get_invoice`, `get_invoice_pdf`
- **Record expenses from receipts**: "Here are five supplier receipts as text. Record each as an expense in Fatture in Cloud with the supplier, date, net amount and VAT, and tell me which ones you were unsure about." → `list_expenses`, `record_expense`
- **Export invoices for your accountant** (runs: weekly): "List last month's issued invoices and recorded expenses in Fatture in Cloud with totals for net, VAT and gross, as a table I can send to my accountant." → `list_invoices`, `list_expenses`

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

Yes. Cotlet does not replace your automation platform: it gives it a Fatture in Cloud 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 fix rejected e-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/fatture-in-cloud/invoices. | 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/fatture-in-cloud/invoices 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 Fatture in Cloud.

### list_invoices

List issued invoices, filtered by date, client or payment status. Access: read. REST: `GET /api/v1/fatture-in-cloud/invoices`. MCP: `fatture_in_cloud_read → list_invoices`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `company_id` | integer | no | Company ID. Optional when your account has one company. |
| `date_from` | string | no | ISO date. Invoices dated on or after it. |
| `date_to` | string | no | ISO date. Invoices dated on or before it. |
| `client_id` | integer | no | Only invoices of this client, from list_clients. |
| `payment_status` | string | no | not_paid or paid. |
| `due_before` | string | no | ISO date. Only invoices with an open payment due before it. |
| `page` | integer | no | Page number, starting at 1. Default: 1. |
| `per_page` | integer | no | Results per page. Default: 50. |

Returns issued invoices with number, date, client, net, VAT and gross amounts and payment status, newest first. Use page and per_page to move through long lists. Needs read access to issued invoices.

Example response:

```json
{
  "invoices": [
    {
      "id": 88120,
      "number": 14,
      "date": "2026-10-02",
      "client": "Rossi Consulting SRL",
      "amount_net": 1500,
      "amount_vat": 330,
      "amount_gross": 1830,
      "payment_status": "not_paid",
      "due_date": "2026-11-01"
    },
    {
      "id": 88121,
      "number": 15,
      "date": "2026-10-03",
      "client": "Studio Verdi SRL",
      "amount_net": 800,
      "amount_vat": 176,
      "amount_gross": 976,
      "payment_status": "paid",
      "due_date": "2026-10-18"
    }
  ],
  "page": 1
}
```

### get_invoice

Get one invoice with its lines, totals and payments. Access: read. REST: `GET /api/v1/fatture-in-cloud/invoices/{invoice_id}`. MCP: `fatture_in_cloud_read → get_invoice`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `company_id` | integer | no | Company ID. Optional when your account has one company. |
| `invoice_id` | integer | yes | Invoice ID from list_invoices or create_invoice. |

Returns the client, the lines with net price, quantity and VAT, the totals and the payments list with due dates and paid status. Use it before recording a payment or building a reminder.

Example response:

```json
{
  "id": 88120,
  "number": 14,
  "date": "2026-10-02",
  "client": {
    "id": 5107,
    "name": "Rossi Consulting SRL"
  },
  "e_invoice": true,
  "lines": [
    {
      "description": "Consulting, 10 hours",
      "quantity": 10,
      "net_price": 150,
      "vat_percent": 22
    }
  ],
  "amount_net": 1500,
  "amount_vat": 330,
  "amount_gross": 1830,
  "payments": [
    {
      "amount": 1830,
      "due_date": "2026-11-01",
      "status": "not_paid"
    }
  ]
}
```

### list_clients

Find clients by name, VAT number or tax code. Access: read. REST: `GET /api/v1/fatture-in-cloud/clients`. MCP: `fatture_in_cloud_read → list_clients`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `company_id` | integer | no | Company ID. Optional when your account has one company. |
| `query` | string | no | Part of the name, VAT number or tax code. |
| `page` | integer | no | Page number, starting at 1. Default: 1. |
| `per_page` | integer | no | Results per page. Default: 50. |

Returns clients with name, VAT number, tax code and e-invoice code where set. Use it to match a client before create_invoice and to avoid creating duplicates.

Example response:

```json
{
  "clients": [
    {
      "id": 5107,
      "name": "Rossi Consulting SRL",
      "vat_number": "01234567890",
      "tax_code": "01234567890",
      "e_invoice_code": "KRRH6B9"
    }
  ],
  "page": 1
}
```

### list_expenses

List received documents (expenses and supplier invoices), filtered by date. Access: read. REST: `GET /api/v1/fatture-in-cloud/expenses`. MCP: `fatture_in_cloud_read → list_expenses`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `company_id` | integer | no | Company ID. Optional when your account has one company. |
| `date_from` | string | no | ISO date. Documents dated on or after it. |
| `date_to` | string | no | ISO date. Documents dated on or before it. |
| `page` | integer | no | Page number, starting at 1. Default: 1. |
| `per_page` | integer | no | Results per page. Default: 50. |

Returns received documents with supplier, date, net, VAT and gross amounts, newest first. Use it to avoid recording the same receipt twice and to export a month for your accountant.

Example response:

```json
{
  "expenses": [
    {
      "id": 3302,
      "date": "2026-10-05",
      "supplier": "Cloud Hosting SRL",
      "description": "Server, October",
      "amount_net": 40,
      "amount_vat": 8.8,
      "amount_gross": 48.8
    }
  ],
  "page": 1
}
```

### get_einvoice_status

Read the SDI status of an invoice. Access: read. REST: `GET /api/v1/fatture-in-cloud/invoices/{invoice_id}/einvoice-status`. MCP: `fatture_in_cloud_read → get_einvoice_status`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `company_id` | integer | no | Company ID. Optional when your account has one company. |
| `invoice_id` | integer | yes | Invoice ID from list_invoices or create_invoice. |

Returns the ei_status of the invoice. Values: attempt, missing, not_sent, sent, pending, processing, error, discarded, not_delivered, accepted, rejected, no_response, manual_accepted, manual_rejected. For discarded invoices, follow with get_einvoice_rejection_reason.

Example response:

```json
{
  "invoice_id": 88120,
  "number": 14,
  "ei_status": "discarded"
}
```

### get_einvoice_rejection_reason

Get the reason SDI rejected an e-invoice. Access: read. REST: `GET /api/v1/fatture-in-cloud/invoices/{invoice_id}/einvoice-rejection-reason`. MCP: `fatture_in_cloud_read → get_einvoice_rejection_reason`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `company_id` | integer | no | Company ID. Optional when your account has one company. |
| `invoice_id` | integer | yes | Invoice ID from list_invoices or create_invoice. |

Returns the reason text, the SDI error code and the date of the rejection for an invoice that SDI discarded. It changes nothing; correcting and resending are separate steps.

Example response:

```json
{
  "invoice_id": 88120,
  "reason": "Customer tax code is incorrect.",
  "code": "0036",
  "date": "2026-10-05"
}
```

### verify_einvoice

Check an invoice's e-invoice XML for errors before sending it to SDI. Access: read. REST: `GET /api/v1/fatture-in-cloud/invoices/{invoice_id}/einvoices/verify`. MCP: `fatture_in_cloud_read → verify_einvoice`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `company_id` | integer | no | Company ID. Optional when your account has one company. |
| `invoice_id` | integer | yes | Invoice ID from list_invoices or create_invoice. |

Runs the XML checks and returns validation errors, for example a problem in a date field. Sends nothing to SDI and changes nothing. Fix errors by editing the invoice in Fatture in Cloud, then verify again.

Example response:

```json
{
  "invoice_id": 88120,
  "valid": false,
  "validation_result": [
    {
      "field": "Data",
      "message": "Invalid date."
    }
  ]
}
```

### get_invoice_pdf

Get a download link for the invoice PDF. Access: read. REST: `GET /api/v1/fatture-in-cloud/invoices/{invoice_id}/pdf`. MCP: `fatture_in_cloud_read → get_invoice_pdf`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `company_id` | integer | no | Company ID. Optional when your account has one company. |
| `invoice_id` | integer | yes | Invoice ID from list_invoices or create_invoice. |

Returns a link to the invoice PDF. Fatture in Cloud changed its document download URLs for security reasons and they expire, so fetch the link right before you use it.

Example response:

```json
{
  "invoice_id": 88120,
  "url": "https://files.example.com/invoice-14.pdf",
  "expires": true
}
```

### create_client

Add a client with name, VAT number or tax code and address. Access: write. REST: `POST /api/v1/fatture-in-cloud/clients`. MCP: `fatture_in_cloud_write → create_client`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `company_id` | integer | no | Company ID. Optional when your account has one company. |
| `name` | string | yes | Client name. |
| `vat_number` | string | no | VAT number. |
| `tax_code` | string | no | Tax code. |
| `address` | object | no | street, postal_code, city, province and country. |
| `e_invoice_code` | string | no | E-invoice code (ei_code) of the client. |
| `certified_email` | string | no | Certified email (PEC) of the client. |

Creates a client and returns its ID. For e-invoices, pass the e-invoice code or certified email. A client reaches nobody and can be deleted in Fatture in Cloud, so this call runs without asking first.

Example response:

```json
{
  "id": 5118,
  "name": "Studio Verdi SRL",
  "vat_number": "09876543210",
  "e_invoice_code": "M5UXCR1"
}
```

### create_invoice

Create an invoice for a client, with lines, VAT and a due date. Access: write, asks the user first. REST: `POST /api/v1/fatture-in-cloud/clients/{client_id}/invoices`. MCP: `fatture_in_cloud_write → create_invoice`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `company_id` | integer | no | Company ID. Optional when your account has one company. |
| `client_id` | integer | yes | Client ID from list_clients or create_client. |
| `date` | string | yes | Invoice date, ISO. |
| `subject` | string | no | Subject shown on the invoice. |
| `e_invoice` | boolean | no | true issues it as an electronic invoice. Default: false. |
| `lines` | array | yes | Objects with description, quantity, net_price and vat_percent. |
| `due_date` | string | no | Payment due date, ISO. |

Creates an invoice, auto-numbered when no number is given, and returns its ID, totals and e-invoice status. Totals are net, VAT and gross, and the due date becomes the payment due date. Creating the invoice does not send it to SDI; use send_einvoice for that. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "id": 88120,
  "number": 14,
  "date": "2026-10-31",
  "client_id": 5107,
  "e_invoice": true,
  "ei_status": "not_sent",
  "amount_net": 1500,
  "amount_vat": 330,
  "amount_gross": 1830,
  "due_date": "2026-11-30"
}
```

### send_einvoice

Send an invoice to the Sistema di Interscambio as an electronic invoice. Access: write, asks the user first. REST: `POST /api/v1/fatture-in-cloud/invoices/{invoice_id}/einvoices`. MCP: `fatture_in_cloud_write → send_einvoice`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `company_id` | integer | no | Company ID. Optional when your account has one company. |
| `invoice_id` | integer | yes | Invoice ID from list_invoices or create_invoice. |
| `dry_run` | boolean | no | true runs the checks without sending to SDI. Default: false. |

Sends the e-invoice to SDI, which delivers it to the client. A sent e-invoice is legally binding and cannot be recalled by this tool. Needs e-invoicing active on the account. Set dry_run to true to run all checks without sending. The call returns at once; read the result later with get_einvoice_status. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "invoice_id": 88120,
  "sent": true,
  "dry_run": false,
  "ei_status": "attempt"
}
```

### record_invoice_payment

Mark an invoice payment as paid, with the date and payment account. Access: write, asks the user first. REST: `POST /api/v1/fatture-in-cloud/payment-accounts/{payment_account_id}/invoices/{invoice_id}/payment`. MCP: `fatture_in_cloud_write → record_invoice_payment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `company_id` | integer | no | Company ID. Optional when your account has one company. |
| `invoice_id` | integer | yes | Invoice ID from list_invoices or create_invoice. |
| `paid_date` | string | yes | Date the money arrived, ISO. |
| `payment_account_id` | integer | yes | Payment account that received it. |

Updates the payment of an invoice to paid on the date you give, against an existing payment account, and returns the updated payments. It changes your books and what your accountant sees. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "invoice_id": 88120,
  "payments": [
    {
      "amount": 1830,
      "due_date": "2026-11-01",
      "paid_date": "2026-10-28",
      "status": "paid"
    }
  ]
}
```

### record_expense

Record an expense with supplier, date and net and VAT amounts. Access: write. REST: `POST /api/v1/fatture-in-cloud/expenses`. MCP: `fatture_in_cloud_write → record_expense`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `company_id` | integer | no | Company ID. Optional when your account has one company. |
| `supplier` | string | yes | Supplier name. |
| `date` | string | yes | Document date, ISO. |
| `description` | string | no | What was bought. |
| `amount_net` | number | yes | Net amount. |
| `vat_percent` | number | yes | VAT rate in percent. |

Creates a received document and returns its ID and totals. It reaches nobody and can be deleted in Fatture in Cloud, so this call runs without asking first. Check list_expenses first to avoid a duplicate.

Example response:

```json
{
  "id": 3310,
  "date": "2026-10-09",
  "supplier": "Office Supplies SRL",
  "amount_net": 60,
  "amount_vat": 13.2,
  "amount_gross": 73.2
}
```

## How do I connect Fatture in Cloud to Claude Code, Codex or Cursor?

Connecting Fatture in Cloud takes three steps: sign up, sign in to Fatture in Cloud 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 Fatture in Cloud to your agent.

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

2. **Sign in to Fatture in Cloud in your Cloud Browser** Open your Cloud Browser in the console: your own Chrome in the cloud. Sign in to Fatture in Cloud 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 Fatture in Cloud 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.

```
Here are this month's three billable clients with hours and rates. Create a Fatture in Cloud invoice for each, add the client first if it is new, check the e-invoice XML and wait for my OK before sending to SDI.
```

### Call Fatture in Cloud 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/fatture-in-cloud 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/fatture-in-cloud/clients/5107/invoices \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"date":"2026-10-31","subject":"October consulting","e_invoice":true,"lines":[{"description":"Consulting, 10 hours","quantity":10,"net_price":150,"vat_percent":22}],"due_date":"2026-11-30"}'
```

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

```
{
  "id": 88120,
  "number": 14,
  "date": "2026-10-31",
  "client_id": 5107,
  "e_invoice": true,
  "ei_status": "not_sent",
  "amount_net": 1500,
  "amount_vat": 330,
  "amount_gross": 1830,
  "due_date": "2026-11-30"
}
```

## Why use Cotlet for Fatture in Cloud?

**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 Fatture in Cloud 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 Fatture in Cloud changes, the tool pauses until we fix it.
- Failed calls cost nothing.

## Is it safe to connect Fatture in Cloud to Cotlet?

Yes. You sign in to Fatture in Cloud yourself, in your own Cloud Browser, and we never save your password. Your agents only get Fatture in Cloud 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 Fatture in Cloud integration?**

No, Cotlet is independent of Fatture in Cloud. Fatture in Cloud's own API is too limited for this work. Cotlet works through your own Fatture in Cloud account, the way you use Fatture in Cloud 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 Fatture in Cloud in your console: your agents lose access at once and you stay signed in. Signing out of Fatture in Cloud in the browser works too, and Reset browser deletes the whole profile.

## Is there a Fatture in Cloud MCP server on GitHub?

Yes. Community Fatture in Cloud MCP servers exist on GitHub, usually maintained by one person. You install one on your own computer, give it an access token from Fatture in Cloud, and keep it running yourself; when the API changes, it stops working until you or the maintainer fix it. The official API is the other route: you register an app or create a token and write the calls yourself. Cotlet hosts the same kind of server for you, signs in to your Fatture in Cloud account in a browser, and our team keeps it working.

|  | GitHub MCP server | Cotlet |
|---|---|---|
| Setup | Create a manual token or an OAuth app, pick scopes and companies, install the server, add the token to each MCP client | Sign up, sign in to Fatture in Cloud once, add one MCP server or API key |
| When Fatture in Cloud changes | It breaks until you or the maintainer fix it | Our team tests it daily and fixes it for you; failed calls are free |
| Your access | A token in a file on your computer; a manual token never expires until you revoke it | 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 stops | Tools fail when you revoke the token or an OAuth refresh token lapses after a year without use | Your Cloud Browser keeps you signed in; if Fatture in Cloud logs 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 software, 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 Fatture in Cloud 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 Fatture in Cloud API cost?

Free 7-day trial with 2,000 credits, no card needed. After that, the Fatture in Cloud 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 20 to 30 credits (25 for most tools, about $0.10 to $0.15), 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 25 credits | Per 1,000 credits |
|---|---|---|---|
| 5,000 | $29 | 200 | $5.80 |
| 15,000 | $79 | 600 | $5.27 |
| 32,000 | $149 | 1,280 | $4.66 |
| 60,000 | $249 | 2,400 | $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 Fatture in Cloud 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 Fatture in Cloud 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 Fatture in Cloud only after you enable it. When Fatture in Cloud 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 Fatture in Cloud, sign out of Fatture in Cloud 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.
- **Fatture in Cloud's terms:** You use your own Fatture in Cloud account and stay responsible for following Fatture in Cloud's terms. Cotlet is independent and not affiliated with Fatture in Cloud. [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 Fatture in Cloud in the console and press Request access. Then you create your API key and connect Fatture in Cloud there.

**Do I need to be technical?**

No. You sign in to Fatture in Cloud 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 Fatture in Cloud to Cotlet?**

Yes. You sign in to Fatture in Cloud yourself, in your own Cloud Browser in the EU, and we never save your password. Your agents only get Fatture in Cloud 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 Fatture in Cloud 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 Fatture in Cloud 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 Fatture in Cloud's pages. It sends the same requests your browser would, from your browser's IP with its cookies, without opening a window. Fatture in Cloud 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 Fatture in Cloud 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?**

Fatture in Cloud 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).

**Does it work without registering an app in Fatture in Cloud?**

Yes. Cotlet signs in to your own account, so you do not register an OAuth app or create a token. The official API needs one or the other, and a sub-user also needs the company admin to grant permissions.

**Can the agent send invoices to SDI on its own?**

It can, but by default you confirm each send_einvoice call, because a sent e-invoice is legally binding. It can run verify_einvoice or a dry run first, which sends nothing.

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

No. Every call to create_invoice, send_einvoice or record_invoice_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. create_client, record_expense runs without asking, because it sends nothing to anyone and one call undoes it.

**Can I use the Fatture in Cloud 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/fatture-in-cloud 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.