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

# Fiken API and MCP server

> Yes, Fiken has a documented REST API (v2) for invoices, sales, purchases, contacts, offers, credit notes and attachments (checked 14 Oct 2026), but it is a paid add-on: 99 NOK per month for a company registered in Brønnøysundregistrene. Apps that serve other companies must register an OAuth2 app, and Fiken publishes no MCP server of its own.

Norwegian cloud accounting for small businesses and sole traders: invoices and offers, purchases with receipts in an inbox, contacts, bank reconciliation and VAT reports in one company account.

## What is the Fiken API?

Cotlet's Fiken API exposes 14 endpoints for your own Fiken account: list contacts, list invoices, get invoice, list purchases, list inbox documents, list bank accounts, create contact, create invoice draft, create invoice, send invoice, register invoice payment, create reminder, upload receipt and create purchase. The list_contacts endpoint returns customers and suppliers with ID, name, organisation number, email and customer or supplier number. Each endpoint takes simple JSON inputs like limit, cursor or invoice_id and works both as an operation of the fiken_read or fiken_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:** 14 (6 read, 8 write)
- **Updated:** 2026-10-20

Yes, Fiken has a documented REST API (v2) for invoices, sales, purchases, contacts, offers, credit notes and attachments (checked 14 Oct 2026), but it is a paid add-on: 99 NOK per month for a company registered in Brønnøysundregistrene. Cotlet is a hosted MCP server and REST API for Fiken with 14 endpoints (6 read, 8 write): you sign in once in your own cloud browser, your AI agent does the work.

## Does Fiken have an official API?

Yes, Fiken has a documented REST API (v2) for invoices, sales, purchases, contacts, offers, credit notes and attachments (checked 14 Oct 2026), but it is a paid add-on: 99 NOK per month for a company registered in Brønnøysundregistrene. Apps that serve other companies must register an OAuth2 app, and Fiken publishes no MCP server of its own.

| Task | Fiken official | Cotlet |
|---|---|---|
| Create invoices and invoice drafts | Yes: Invoice drafts, createInvoice and invoices endpoints | Yes |
| Send an invoice to the customer | Yes: POST invoices/send with email, EHF, eFaktura, SMS, letter or auto | Yes |
| Register a customer payment on an invoice | Yes: Sales payments endpoint, amount, date and bank account | Yes |
| List unpaid and overdue invoices | Yes: Invoice filters on settled and due date | Yes |
| Create customer and supplier contacts | Yes: Contacts endpoint | Yes |
| Register purchases from receipts and supplier invoices | Yes: Purchases and purchase drafts, with attachments | Yes |
| Upload receipts to the inbox | Yes: Inbox endpoint takes a file upload | Yes |
| Send a payment reminder or dunning letter | No: No reminder endpoint in the API docs; done in Fiken under Veiviser for forfalt faktura | Yes |

Sources: [Fiken API v2 documentation](https://api.fiken.no/api/v2/docs/), [Fiken Help: Hvordan bruke Fikens API](https://hjelp.fiken.no/api), [Fiken Help: Hvordan lage faktura i Fiken](https://hjelp.fiken.no/hvordan-lage-faktura-i-fiken), [Fiken Help: Registrere kjøp og utgifter](https://hjelp.fiken.no/registrere-kjoep-og-utgifter)

## For AI agents

```text
Yes, Fiken has a documented REST API (v2) for invoices, sales, purchases, contacts, offers, credit notes and attachments (checked 14 Oct 2026), but it is a paid add-on: 99 NOK per month for a company registered in Brønnøysundregistrene. Apps that serve other companies must register an OAuth2 app, and Fiken publishes no MCP server of its own.
Cotlet provides a hosted MCP server and REST API for Fiken: 14 tools (6 read, 8 write).
Access       Sign up at https://cotlet.dev/app/signup?app=fiken, then request the app and create API keys in the Cotlet console.

MCP server   https://cotlet.dev/mcp/v1
MCP tools    fiken_read, fiken_write, reads and writes apart; call one with {"operation": "<operation>", "arguments": {...}}
REST base    https://cotlet.dev/api/v1/fiken, each operation at its own route, e.g. POST /api/v1/fiken/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_contacts, list_invoices, get_invoice, list_purchases, list_inbox, list_bank_accounts, create_contact, create_invoice_draft, create_invoice, send_invoice, register_invoice_payment, create_reminder, upload_receipt, create_purchase
Confirm      create_invoice, send_invoice, register_invoice_payment, create_reminder, create_purchase (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/fiken-api-mcp-server.md

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

## What can an AI agent do in Fiken?

Cotlet is best for sole traders, small companies and bookkeepers on Fiken who want invoices, payment reminders and receipts handled by an agent without running or fixing a server.

- **[Create and send invoices from a list](https://cotlet.dev/integrations/fiken-api-mcp-server/create-and-send-invoices.md)**: "Here is this month's billing list. For each customer, create the invoice in Fiken with the hours and rate I gave, due in 14 days, and send it by the customer's usual method. Create contacts that do not exist yet." → `list_contacts`, `create_contact`, `create_invoice_draft`, `create_invoice`, `send_invoice`
- **[Chase overdue invoices](https://cotlet.dev/integrations/fiken-api-mcp-server/chase-overdue-invoices.md)** (runs: weekly): "Every Monday, find overdue invoices in Fiken. Send a reminder by email to those up to 13 days overdue and a dunning letter to those 14 to 44 days overdue. List anything older for me and do not touch it." → `list_invoices`, `get_invoice`, `create_reminder`
- **[Book receipts as purchases](https://cotlet.dev/integrations/fiken-api-mcp-server/book-receipts-as-purchases.md)** (runs: weekly): "Go through the unused documents in my Fiken inbox. Book each one as a purchase with the supplier, date, amount and VAT from the document, use the cost accounts from my list, and leave anything unclear for me." → `list_inbox`, `list_contacts`, `create_contact`, `list_purchases`, `create_purchase`
- **Register customer payments on invoices** (runs: daily): "Here are yesterday's incoming payments. Find the matching unpaid invoice in Fiken by invoice number, register each payment on the bank account it arrived on, and list anything that does not match." → `list_invoices`, `get_invoice`, `list_bank_accounts`, `register_invoice_payment`
- **See what you owe suppliers** (runs: weekly): "Every Monday, list the unpaid purchases in Fiken that fall due in the next 14 days, with supplier, amount and due date, and give me the total." → `list_purchases`

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

Yes. Cotlet does not replace your automation platform: it gives it a Fiken 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 chase overdue 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/fiken/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/fiken/invoices with your API key. | cron or GitHub Actions. |

## Tools

**For AI agents:** Every endpoint and its schema is public. The 14 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 Fiken.

### list_contacts

Customers and suppliers with ID, name, organisation number, email and customer or supplier number. Access: read. REST: `GET /api/v1/fiken/contacts`. MCP: `fiken_read → list_contacts`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `search` | string | no | Contact name or organisation number. |
| `role` | enum | no | all, customer or supplier. Default: all. |
| `limit` | integer | no | 1 to 100. Default: 25. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists the contacts of the company. Search by name or organisation number to check whether a contact exists before creating one, and filter by role to get only customers or only suppliers. Use contact_id as customer_id in create_invoice and as supplier_id in create_purchase. Pages hold up to 100 contacts; pass next_cursor back as cursor for the next page.

Example response:

```json
{
  "contacts": [
    {
      "contact_id": 4021188,
      "name": "Nordlys Design AS",
      "organisation_number": "912345678",
      "email": "okonomi@nordlys.example",
      "customer_number": 10003,
      "supplier_number": null
    }
  ],
  "next_cursor": null
}
```

### list_invoices

Sales invoices with number, customer, dates, gross amount and remaining balance. Access: read. REST: `GET /api/v1/fiken/invoices`. MCP: `fiken_read → list_invoices`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | enum | no | all, unpaid, overdue, paid or draft. Default: all. |
| `customer_id` | integer | no | Only invoices for this contact. |
| `due_before` | date | no | Only invoices with a due date before this date. |
| `limit` | integer | no | 1 to 100. Default: 25. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists the invoices of the company, oldest due date first. Filter by status to find unpaid and overdue invoices; overdue means unpaid and past the due date, and draft returns the drafts shown under Utkast in Fiken. Each item holds totals only; get_invoice returns the lines and payments. Pages hold up to 100 invoices.

Example response:

```json
{
  "invoices": [
    {
      "invoice_id": 5120288,
      "invoice_number": 10031,
      "customer_id": 4020977,
      "customer": "Havbris Maritim AS",
      "issue_date": "2026-09-16",
      "due_date": "2026-09-30",
      "gross": 8750,
      "balance": 8750,
      "currency": "NOK",
      "status": "overdue"
    }
  ],
  "next_cursor": null
}
```

### get_invoice

One invoice with its lines, totals, sent state and payments. Access: read. REST: `GET /api/v1/fiken/invoices/{invoice_id}`. MCP: `fiken_read → get_invoice`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `invoice_id` | integer | yes | Invoice ID from list_invoices or create_invoice. |

Returns one invoice with every line, net, VAT and gross, the balance still open, whether and how it was sent, the payments registered so far and any credit notes. Read it before register_invoice_payment so a short payment is registered as partial, and before create_reminder so a paid invoice is not chased.

Example response:

```json
{
  "invoice_id": 5120288,
  "invoice_number": 10031,
  "customer_id": 4020977,
  "customer": "Havbris Maritim AS",
  "issue_date": "2026-09-16",
  "due_date": "2026-09-30",
  "lines": [
    {
      "description": "Harbour survey, September",
      "quantity": 5,
      "unit_price": 1400,
      "vat_type": "HIGH",
      "net": 7000
    }
  ],
  "net": 7000,
  "vat": 1750,
  "gross": 8750,
  "balance": 8750,
  "sent": true,
  "payments": [],
  "credit_notes": [],
  "currency": "NOK"
}
```

### list_purchases

Purchases with supplier, date, invoice number, gross amount and what is still unpaid. Access: read. REST: `GET /api/v1/fiken/purchases`. MCP: `fiken_read → list_purchases`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `paid` | enum | no | all, paid or unpaid. Default: all. |
| `from` | date | no | Purchase date on or after this date. |
| `to` | date | no | Purchase date on or before this date. |
| `supplier_id` | integer | no | Only purchases from this contact. |
| `limit` | integer | no | 1 to 100. Default: 25. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists registered purchases, newest first. Filter by payment status and by date range to see what you still owe, or to check whether a supplier invoice number is already booked before create_purchase. Each item holds totals only. Pages hold up to 100 purchases.

Example response:

```json
{
  "purchases": [
    {
      "purchase_id": 8820090,
      "date": "2026-10-02",
      "supplier": "Kontorbutikken AS",
      "invoice_number": "88213",
      "gross": 640,
      "balance": 640,
      "due_date": "2026-10-16",
      "currency": "NOK",
      "paid": false
    }
  ],
  "next_cursor": null
}
```

### list_inbox

Documents in the Fiken inbox with name, upload date and whether they are used. Access: read. REST: `GET /api/v1/fiken/inbox`. MCP: `fiken_read → list_inbox`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | enum | no | all, unused or used. Default: all. |
| `name` | string | no | Part of the document name. |
| `limit` | integer | no | 1 to 100. Default: 25. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists the documents in Innboks, newest first. A document is used once it is attached to a purchase, sale or draft; filter by unused to get the receipts that still need booking. Each item has a document_url the agent can open to read the file. Deleting a purchase does not delete its document from the inbox.

Example response:

```json
{
  "documents": [
    {
      "document_id": 3318240,
      "name": "Kontorbutikken faktura 88214",
      "filename": "faktura-88214.pdf",
      "created_at": "2026-10-12T08:14:00+02:00",
      "used": false,
      "document_url": "https://fiken.no/documents/3318240"
    }
  ],
  "next_cursor": null
}
```

### list_bank_accounts

Bank accounts registered in the company, with the account code payments are booked on. Access: read. REST: `GET /api/v1/fiken/bank-accounts`. MCP: `fiken_read → list_bank_accounts`.

No parameters.

Returns the bank accounts of the company with name, account code and bank account number, and whether an account is inactive. Use the account code as bank_account in register_invoice_payment and create_purchase. Accounts are added in Fiken, not by this tool.

Example response:

```json
{
  "bank_accounts": [
    {
      "bank_account": "1920:10001",
      "name": "Driftskonto",
      "bank_account_number": "15035646830",
      "inactive": false
    }
  ]
}
```

### create_contact

Add a customer or supplier with name, email and organisation number. Access: write. REST: `POST /api/v1/fiken/contacts`. MCP: `fiken_write → create_contact`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `name` | string | yes | Contact name, up to 200 characters. |
| `role` | enum | no | customer or supplier. Default: customer. |
| `email` | string | no | Email address for invoices. |
| `organisation_number` | string | no | Organisation number from Brønnøysundregistrene. |
| `phone_number` | string | no | Phone number, needed to send invoices by SMS. |

Adds one contact to Fiken and returns its contact_id and, for a customer, the customer number Fiken assigns. Run list_contacts first so you do not create a duplicate. create_contact runs without asking first: it sends nothing to anyone, books nothing, and the contact can be edited in Fiken afterwards.

Example response:

```json
{
  "contact_id": 4021190,
  "name": "Fjord Studio AS",
  "organisation_number": "987654321",
  "email": "faktura@fjord.example",
  "customer_number": 10004,
  "supplier_number": null
}
```

### create_invoice_draft

Save an invoice draft for a customer. Nothing is booked and nothing is sent. Access: write. REST: `POST /api/v1/fiken/customers/{customer_id}/invoice-drafts`. MCP: `fiken_write → create_invoice_draft`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `customer_id` | integer | yes | Contact ID from list_contacts or create_contact. |
| `issue_date` | date | no | Invoice date. Default: today. |
| `days_until_due` | integer | yes | Days from the invoice date to the due date. |
| `lines` | array | yes | Objects with description, quantity, unit_price (net per unit, excluding VAT), vat_type (for example HIGH, MEDIUM, LOW or NONE), optional discount_percent and income_account. A line without a product needs an income account. |
| `invoice_text` | string | no | Comment printed above the invoice lines. |
| `your_reference` | string | no | Your reference, printed on the invoice. |
| `currency` | string | no | ISO 4217 code. Default: NOK. |

Saves a draft like Lagre utkast in Fiken and returns its draft_id. The draft shows under Utkast at the top of Salg → Faktura-/salgsoversikt, where you can open and change it. Nothing is booked, no invoice number is used and the customer hears nothing, so create_invoice_draft runs without asking first. Pass the draft_id to create_invoice to issue it.

Example response:

```json
{
  "draft_id": 771204,
  "customer_id": 4021188,
  "customer": "Nordlys Design AS",
  "issue_date": "2026-10-14",
  "due_date": "2026-10-28",
  "net": 12000,
  "vat": 3000,
  "gross": 15000,
  "currency": "NOK"
}
```

### create_invoice

Issue an invoice and book the income. It is created, not sent. Access: write, asks the user first. REST: `POST /api/v1/fiken/invoices`. MCP: `fiken_write → create_invoice`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `draft_id` | integer | no | Draft ID from create_invoice_draft. Use this or the fields below. |
| `customer_id` | integer | no | Contact ID. Required without draft_id. |
| `issue_date` | date | no | Invoice date. Default: today. |
| `days_until_due` | integer | no | Days from the invoice date to the due date. Required without draft_id. |
| `lines` | array | no | Required without draft_id. Objects with description, quantity, unit_price (net per unit, excluding VAT), vat_type (for example HIGH, MEDIUM, LOW or NONE), optional discount_percent and income_account. |
| `invoice_text` | string | no | Comment printed above the invoice lines. |
| `your_reference` | string | no | Your reference, printed on the invoice. |
| `currency` | string | no | ISO 4217 code. Default: NOK. |

Creates the invoice, like Opprett faktura in Fiken, from lines or from a draft_id, and registers the income in the accounts. It returns the invoice number and totals; the customer gets nothing until send_invoice runs. Fiken has no delete for invoices: a wrong invoice is corrected with a credit note in Fiken. Pass draft_id to issue a draft, or customer_id, days_until_due and lines to create one directly. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "invoice_id": 5120331,
  "invoice_number": 10042,
  "customer_id": 4021188,
  "customer": "Nordlys Design AS",
  "issue_date": "2026-10-14",
  "due_date": "2026-10-28",
  "net": 12000,
  "vat": 3000,
  "gross": 15000,
  "currency": "NOK",
  "sent": false
}
```

### send_invoice

Send an invoice to the customer by EHF, eFaktura, email, SMS or letter. Access: write, asks the user first. REST: `POST /api/v1/fiken/invoices/{invoice_id}`. MCP: `fiken_write → send_invoice`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `invoice_id` | integer | yes | Invoice ID from list_invoices or create_invoice. |
| `method` | enum | no | auto, email, ehf, efaktura, sms or letter. Default: auto. |
| `recipient_email` | string | no | Email address if different from the contact. |
| `message` | string | no | Message sent with the invoice. |
| `include_attachments` | boolean | no | Send the invoice attachments too. Not used for letter. Default: true. |

Sends an issued invoice to the customer, as the sending window after Opprett faktura does. Method auto tries EHF, eFaktura, SMS and email in that order, based on what is registered for the contact. SMS only reaches Norwegian numbers, eFaktura needs the company to have approved information exchange with the eFaktura register, and a letter is posted for an extra charge to addresses in Norway only. Invoices sent by eFaktura have their payments registered by hand unless you have a KID agreement. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "invoice_id": 5120331,
  "invoice_number": 10042,
  "method": "ehf",
  "to": "Nordlys Design AS",
  "sent": true
}
```

### register_invoice_payment

Register a received payment, full or partial, on a customer invoice. Access: write, asks the user first. REST: `POST /api/v1/fiken/invoices/{invoice_id}/payment`. MCP: `fiken_write → register_invoice_payment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `invoice_id` | integer | yes | Invoice ID from list_invoices or create_invoice. |
| `amount` | number | yes | Amount received, in the invoice currency. |
| `payment_date` | date | no | Date the money arrived. Default: today. |
| `bank_account` | string | yes | Account code from list_bank_accounts, e.g. 1920:10001. |

Registers a payment on one invoice with the bank account, the date and the amount you give, like Registrer ny innbetaling in Fiken. A payment lower than the balance leaves the invoice open for the rest; one that covers it marks the invoice as settled. Read the balance with get_invoice first, and take the bank account from list_bank_accounts. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "invoice_id": 5120301,
  "invoice_number": 10037,
  "paid_amount": 15000,
  "payment_date": "2026-10-13",
  "bank_account": "1920:10001",
  "balance": 0,
  "status": "settled",
  "currency": "NOK"
}
```

### create_reminder

Send a payment reminder or a dunning letter for an overdue invoice. Access: write, asks the user first. REST: `POST /api/v1/fiken/invoices/{invoice_id}/reminders`. MCP: `fiken_write → create_reminder`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `invoice_id` | integer | yes | Invoice ID from list_invoices or create_invoice. |
| `type` | enum | yes | reminder or dunning. |
| `method` | enum | no | email or letter. Default: email. |

Follows up an invoice yourself, as Veiviser for forfalt faktura → Lag en påminnelse eller purring → Følg opp på egenhånd does. Type reminder is a payment reminder, type dunning is a purring. Fiken offers no reminder before the due date, and no fee or collection step until 14 days after it, so earlier calls fail. Reminders go out by email or letter, never as EHF. Sending a case to external follow-up (inkasso) is not part of this tool. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "invoice_id": 5120288,
  "invoice_number": 10031,
  "type": "reminder",
  "method": "email",
  "to": "okonomi@havbris.example",
  "days_overdue": 14
}
```

### upload_receipt

Put a receipt or supplier invoice in the Fiken inbox so it can be attached to a purchase. Access: write. REST: `POST /api/v1/fiken/receipts`. MCP: `fiken_write → upload_receipt`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `file_url` | string | yes | https link to the PDF or image to upload. |
| `name` | string | no | Document name shown in the inbox. Default: the file name. |
| `description` | string | no | Extra description saved with the document. |

Uploads one file to Innboks from an https link the agent can reach, and returns its document_id and inbox status unused. It books nothing and sends nothing to anyone: the document waits in the inbox until create_purchase or a person in Fiken uses it, so upload_receipt runs without asking first.

Example response:

```json
{
  "document_id": 3318251,
  "name": "Hotel Fjordgaten receipt",
  "filename": "hotel-receipt.pdf",
  "created_at": "2026-10-14T09:02:00+02:00",
  "used": false
}
```

### create_purchase

Register a purchase from a supplier or a cash purchase, with VAT, cost account and payment. Access: write, asks the user first. REST: `POST /api/v1/fiken/purchases`. MCP: `fiken_write → create_purchase`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `kind` | enum | yes | supplier or cash_purchase. |
| `supplier_id` | integer | no | Contact ID from list_contacts. Required for supplier. |
| `date` | date | yes | Invoice or receipt date. |
| `invoice_number` | string | no | The supplier's invoice number, used to avoid booking a document twice. |
| `due_date` | date | no | Due date, if different from the invoice date. |
| `lines` | array | yes | Objects with description, gross_amount, vat_type (for example HIGH, MEDIUM, LOW or NONE) and expense_account. Several objects split the purchase. |
| `paid_from` | enum | no | bank_account, cash, out_of_pocket or unpaid. Default: unpaid. |
| `bank_account` | string | no | Account code from list_bank_accounts. Required for bank_account. |
| `payment_date` | date | no | Date of payment. Default: the purchase date. |
| `inbox_document_id` | integer | no | Document ID from list_inbox or upload_receipt. |
| `currency` | string | no | ISO 4217 code. Default: NOK. |

Registers one purchase like Registrer kjøp in Fiken: a supplier purchase (kjøp fra leverandør) or a cash purchase (kontantkjøp), with one or more lines of gross amount, VAT type and cost account. Attach a document with inbox_document_id. paid_from is bank_account, cash, out_of_pocket (Utlegg, paid by you personally) or unpaid; an unpaid purchase is paid later in Fiken. A booked purchase cannot be edited directly: Fiken cancels the booking and makes a new draft. Check list_purchases for the same invoice number first. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "purchase_id": 8820145,
  "kind": "supplier",
  "supplier": "Kontorbutikken AS",
  "date": "2026-10-09",
  "invoice_number": "88214",
  "net": 1000,
  "vat": 250,
  "gross": 1250,
  "currency": "NOK",
  "paid": true,
  "balance": 0,
  "document_attached": true
}
```

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

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

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

2. **Sign in to Fiken in your Cloud Browser** Open your Cloud Browser in the console: your own Chrome in the cloud. Sign in to Fiken 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 Fiken 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 is this month's billing list. For each customer, create the invoice in Fiken with the hours and rate I gave, due in 14 days, and send it by the customer's usual method. Create contacts that do not exist yet.
```

### Call Fiken 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/fiken 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/fiken/invoices \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"customer_id":4021188,"issue_date":"2026-10-14","days_until_due":14,"lines":[{"description":"Consulting, October","quantity":10,"unit_price":1200,"vat_type":"HIGH"}]}'
```

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

```
{
  "invoice_id": 5120331,
  "invoice_number": 10042,
  "customer_id": 4021188,
  "customer": "Nordlys Design AS",
  "issue_date": "2026-10-14",
  "due_date": "2026-10-28",
  "net": 12000,
  "vat": 3000,
  "gross": 15000,
  "currency": "NOK",
  "sent": false
}
```

## Why use Cotlet for Fiken?

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

## Is it safe to connect Fiken to Cotlet?

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

No, Cotlet is independent of Fiken. Fiken's own API comes only with a paid plan. Cotlet works through your own Fiken account, the way you use Fiken 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 Fiken in your console: your agents lose access at once and you stay signed in. Signing out of Fiken in the browser works too, and Reset browser deletes the whole profile.

## Is there a Fiken MCP server on GitHub?

Yes. Community Fiken MCP servers exist on GitHub, some read-only and some that also write, usually maintained by one person. You install one on your own computer, give it a personal API token from Fiken, and keep it running yourself; the API module has to be ordered first, and when Fiken changes its API the server stops working until you or the maintainer fix it. The official API is the other route: you order the module and build the calls yourself. Cotlet hosts the same kind of server for you, signs in to your Fiken account in a browser, and our team keeps it working.

|  | GitHub MCP server | Cotlet |
|---|---|---|
| Setup | Order the API module in Fiken, create a personal API token, install the server, add the token and company to each MCP client | Sign up, sign in to Fiken once, add one MCP server or API key |
| When Fiken 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 Fiken access | A personal API token in a file on your computer; it 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 the API changes | Your Cloud Browser keeps you signed in; if Fiken 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, plus 99 NOK per month for the Fiken API module | Free 7-day trial, then pay-as-you-go credit packs, no subscription; no Fiken API module needed |

### 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 Fiken 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 Fiken API cost?

Free 7-day trial with 2,000 credits, no card needed. After that, the Fiken 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 Fiken 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 Fiken 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 Fiken only after you enable it. When Fiken 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 Fiken, sign out of Fiken 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.
- **Fiken's terms:** You use your own Fiken account and stay responsible for following Fiken's terms. Cotlet is independent and not affiliated with Fiken. [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 Fiken in the console and press Request access. Then you create your API key and connect Fiken there.

**Do I need to be technical?**

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

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

Fiken 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 the Fiken API module to use Cotlet?**

No. Cotlet signs in to your Fiken account in a browser like you do, so you do not order the API module, create a personal API token or register an OAuth app. For comparison, Fiken charges 99 NOK per month for the API module on a company registered in Brønnøysundregistrene.

**Which Fiken access type does my user need?**

Cotlet works with the access your own user has. Hele regnskapet can do everything in the books, including invoices and purchases. Se regnskapet uten å kunne gjøre endringer can only view, so only the list tools work for that user.

**Can my agent delete or correct an invoice?**

No. Fiken does not allow deleting an invoice, because the bookkeeping law requires a credit note instead, and Cotlet has no tool that creates credit notes. Create the credit note in Fiken with Opprett kreditnota for faktura.

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

No. Every call to create_invoice, send_invoice, register_invoice_payment, create_reminder or create_purchase 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_contact, create_invoice_draft, upload_receipt runs without asking, because it sends nothing to anyone and one call undoes it.

**Can I use the Fiken 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/fiken 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.