Fortnox MCP-server: koppla bokföringen till Claude 2026

Q: Kan jag använda den här servern i Claude.ai webb?

Nej — MCP fungerar via Claude Desktop, Claude Code och vissa andra klienter. Claude.ai-webben stöder inte lokala MCP-servrar ännu.

Q: Är det säkert att ge AI tillgång till bokföringen?

Read-only på icke-känslig data: troligen OK. Skriv-åtkomst eller känslig data som löner: nej, inte utan ytterligare säkerhetslager.

Experimentell teknik. Model Context Protocol (MCP) är en Anthropic-standard från 2024-25 för hur AI-assistenter ansluter till externa datakällor. Den här guiden bygger en Fortnox MCP-server så att du kan fråga Claude Desktop “visa obetalda fakturor” och få verkligt svar. Detta är ingen produktionslösning — det är en kraftfull demo och en inblick i vart bokföring + AI är på väg.

Jag byggde den första versionen av det här över en helg efter att Anthropic släppte MCP-specen. Reaktionen i svenska tech-communities har varit starkt delad — några tycker det är genialt, andra är livrädda för att ge en LLM åtkomst till ekonomidata. Båda har poänger.

Den här guiden visar minsta fungerande skeleton, en riktig demo och de säkerhetsbegränsningar som är kritiska att förstå.

Vad är MCP?

Model Context Protocol är en öppen standard från Anthropic som definierar hur en AI-klient (t.ex. Claude Desktop) kan ansluta till externa verktyg och datakällor. Arkitekturen är enkel:

MCP-klient: Claude Desktop, Claude Code eller annan AI-applikation
MCP-server: en process som du kör lokalt som exponerar “tools” (funktioner) och “resources” (data)
Transport: stdio (lokal) eller HTTP/SSE (fjärran)

När du frågar Claude något som matchar en tool-beskrivning, anropar Claude servern, får svaret och formulerar ett svar baserat på datan.

I vårt fall exponerar servern verktyg som list_unpaid_invoices, get_customer och create_draft_invoice — alla implementerade som tunna wrappers runt Fortnox API.

Varför koppla bokföring till AI?

De konkreta användningsfallen jag stött på:

Frågor i naturligt språk: “Vilka kunder är försenade med betalning mer än 30 dagar?”
Utkast till fakturor: “Skapa ett fakturautkast till Acme AB för 10 timmar support i april”
Sammanfattningar: “Vad har jag fakturerat Acme AB senaste året?”
Analys: “Vilka tre kunder står för störst andel av intäkterna Q1?”

Det är inte att “AI sköter bokföringen” — det är att du får en bättre frågeresponse-upplevelse ovanpå data du redan har.

Anthropic Claude Desktop setup

Installera Claude Desktop från claude.ai/download
Lokalisera config-filen:
- macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
- Windows: %APPDATA%\Claude\claude_desktop_config.json
Lägg till din MCP-server där. Exempel:

{
  "mcpServers": {
    "fortnox": {
      "command": "python",
      "args": ["/absolut/sokvag/till/fortnox_mcp_server.py"],
      "env": {
        "FORTNOX_ACCESS_TOKEN": "din-access-token",
        "FORTNOX_CLIENT_SECRET": "din-client-secret"
      }
    }
  }
}

Starta om Claude Desktop
Du borde se “fortnox” i MCP-indikatorn i UI:et

Komplett MCP-server skeleton (Python)

Nedan är en minimal men fungerande Fortnox MCP-server. Den använder Python mcp SDK (officiell) och exponerar tre verktyg.

"""
fortnox_mcp_server.py
Minimal MCP-server som exponerar Fortnox-data till Claude Desktop.
"""
import asyncio
import os
from typing import Any

import httpx
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent

API_BASE = "https://api.fortnox.se/3"
TOKEN = os.environ["FORTNOX_ACCESS_TOKEN"]

server = Server("fortnox")


async def fortnox_get(path: str, params: dict | None = None) -> dict:
    async with httpx.AsyncClient(timeout=15) as client:
        r = await client.get(
            f"{API_BASE}{path}",
            headers={
                "Authorization": f"Bearer {TOKEN}",
                "Accept": "application/json",
            },
            params=params or {},
        )
        r.raise_for_status()
        return r.json()


@server.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="list_unpaid_invoices",
            description="Lista alla obetalda fakturor i Fortnox",
            inputSchema={
                "type": "object",
                "properties": {},
            },
        ),
        Tool(
            name="get_customer",
            description="Hämta kunddetaljer för ett CustomerNumber",
            inputSchema={
                "type": "object",
                "properties": {
                    "customer_number": {"type": "string"},
                },
                "required": ["customer_number"],
            },
        ),
        Tool(
            name="list_top_customers",
            description="Lista kunder sorterade efter total fakturering",
            inputSchema={
                "type": "object",
                "properties": {
                    "limit": {"type": "integer", "default": 5},
                },
            },
        ),
    ]


@server.call_tool()
async def call_tool(name: str, args: dict[str, Any]) -> list[TextContent]:
    if name == "list_unpaid_invoices":
        data = await fortnox_get(
            "/invoices",
            params={"filter": "unpaid", "limit": 50},
        )
        lines = [
            f"#{inv['DocumentNumber']} — {inv['CustomerName']} — "
            f"{inv['Balance']} {inv['Currency']} (förfallen {inv['DueDate']})"
            for inv in data.get("Invoices", [])
        ]
        return [TextContent(type="text", text="\n".join(lines) or "Inga obetalda fakturor.")]

    if name == "get_customer":
        data = await fortnox_get(f"/customers/{args['customer_number']}")
        c = data.get("Customer", {})
        return [TextContent(
            type="text",
            text=f"{c.get('Name')} — {c.get('Email')} — orgnr {c.get('OrganisationNumber')}"
        )]

    if name == "list_top_customers":
        data = await fortnox_get("/invoices", params={"limit": 500})
        totals: dict[str, float] = {}
        for inv in data.get("Invoices", []):
            totals[inv["CustomerName"]] = totals.get(inv["CustomerName"], 0) + float(inv.get("Total", 0))
        top = sorted(totals.items(), key=lambda x: -x[1])[:args.get("limit", 5)]
        return [TextContent(
            type="text",
            text="\n".join(f"{name}: {total:,.0f} SEK" for name, total in top)
        )]

    return [TextContent(type="text", text=f"Okänt verktyg: {name}")]


async def main():
    async with stdio_server() as (read, write):
        await server.run(read, write, server.create_initialization_options())


if __name__ == "__main__":
    asyncio.run(main())

Installera beroenden:

pip install mcp httpx

Och kör:

export FORTNOX_ACCESS_TOKEN="din-token"
python fortnox_mcp_server.py

Demo: fråga Claude om obetalda fakturor

När servern är konfigurerad i Claude Desktop kan du skriva:

“Visa mig obetalda fakturor och summera totalbeloppet.”

Claude kommer:

Upptäcka att list_unpaid_invoices-verktyget matchar
Anropa MCP-servern
Få tillbaka JSON-data via servern → Fortnox API
Formatera ett sammanhängande svar med tabell + summering

Första gången jag provade det här i skarpt läge — med 40+ obetalda fakturor — kändes det som att få en personlig assistent. “Vilka tre kunder ska jag ringa i morgon?” → Claude rankar efter förfallodagar och belopp. Det är inte magi, men det är en markant uppgradering jämfört med att själv klicka runt i Fortnox-UI:et.

Säkerhet och begränsningar

Här är anledningen till att jag rubricerade det här som experimentellt.

Risker

Access_token i Claude Desktop-config. Token lagras i klartext i config-filen. Om din dator blir komprometterad har angriparen fullständig bokföringsåtkomst.
Read-only är säkrare. Min demo-server har bara GET-verktyg. Undvik att exponera create_invoice eller andra skriv-endpoints i första versionen.
Prompt injection. Om Claude summerar en faktura-beskrivning som någon annan skrivit, kan den beskrivningen innehålla instruktioner som Claude potentiellt tolkar. Sanera input innan den går till modellen.
Dataläckage. Claudes moderegel är att all data du ser kan hamna i Anthropics loggar. Känslig kunddata (personnummer, löner) bör aldrig passera MCP till en molnmodell utan att du läst Anthropics datapolicy.
Rate limits. Fortnox 25 req/5s gäller — en chatt som kräver 10 subqueries kan trigga 429.

Rekommendationer

Börja read-only. Skriv-verktyg kan läggas till senare med bekräftelse-steg.
Håll servern lokal. Kör över stdio, inte HTTP, under utveckling.
Rotera tokens ofta. Refresh_token → access_token dagligen via separat process.
Logga allt. Om något går fel i produktion vill du kunna bevisa vad som hände.
Använd scope-begränsning. Skapa en Fortnox-integration med minsta möjliga scope (invoice read-only räcker för demon ovan).

Framtid

MCP är fortfarande tidigt. Spec:en uppdateras och implementationer dyker upp för nya klienter (Cursor, Zed, Sourcegraph). Det jag räknar med under 2026-27:

Officiella MCP-servrar från bokföringsleverantörerna själva. Fortnox eller Spiris är logiska kandidater att publicera sina egna.
OAuth-flows inbyggt i MCP. Slipper att lägga access_tokens i config.
Multi-tenant-stöd. En enda server som hanterar flera Fortnox-tenants med auth per session.
Skriv-verktyg med human-in-the-loop-godkännande. Claude föreslår fakturautkast; du trycker godkänn.

Om du vill ligga i framkant är det nu du ska experimentera. Verkligen produktionsmogna MCP-integrationer för svensk bokföring kommer dyka upp de närmsta 12 månaderna — antingen från leverantörerna själva eller från en tredjepart (kanske du?).

Relaterad läsning: Fortnox API-guide och Automatisera fakturering.

FAQ

Vad är skillnaden mellan MCP och ett vanligt API?

MCP är ett standardiserat protokoll för hur AI-klienter upptäcker och anropar verktyg. Fortnox API är datalagret. MCP-servern är tolklagret som berättar för Claude vilka verktyg som finns och hur de ska anropas.

Kan jag använda den här servern i Claude.ai webb?

Nej — MCP fungerar i dagsläget via Claude Desktop, Claude Code och vissa andra klienter. Claude.ai-webben stöder inte lokala MCP-servrar (dokumentationen 2026 indikerar att det kan komma).

Fungerar det med ChatGPT?

Inte direkt. MCP är Anthropics protokoll, men det har adopterats av Cursor, Zed och fler klienter. OpenAI har egna protokoll (function calling). Det finns adapter-projekt som bryggar MCP ↔ OpenAI.

Är det säkert att ge AI tillgång till bokföringen?

Read-only på icke-känslig data: troligen OK för enskilda firmor. Skriv-åtkomst eller känslig data (löner, personnummer): nej, inte utan ytterligare säkerhetslager.

Hur mycket tid tar det att bygga?

Det här skeletonet: några timmar. Produktionsmogen lösning med OAuth, multi-tenant och felhantering: 2-4 veckor.

Behöver jag betala Anthropic?

Du behöver en Claude.ai-prenumeration (Pro från 20 USD/mån) för att köra Claude Desktop med rimliga gränser. MCP i sig är öppen standard.

Fortnox MCP-server är ett kraftfullt experiment som förhandsvisar hur vi kommer interagera med bokföringsdata framöver. Det är inte redo för att ersätta Fortnox-UI — men det är redo att imponera på din CFO och spara dig ett par timmar i veckan. Börja read-only, läs Anthropics säkerhetsdokumentation, och lek vidare.