Connect Sellsy to Claude: Query Records and Sync Information

If your team needs to connect Sellsy to Claude to automate CRM workflows, query financial records, or sync customer data, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's function-calling capabilities and Sellsy's REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses ChatGPT instead of Claude, check out our guide on connecting Sellsy to ChatGPT. For a broader architectural overview of agentic workflows, explore our guide on connecting Sellsy to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling combined CRM and ERP platform like Sellsy is a massive engineering undertaking. You have to handle OAuth 2.0 token lifecycles, map hundreds of distinct JSON schemas to MCP tool definitions, and navigate Sellsy's strict domain logic around invoicing compliance and custom fields.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Sellsy, connect it natively to Claude, and execute complex business workflows using natural language.

The Engineering Reality of the Sellsy API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools over JSON-RPC, the reality of implementing it against a highly specialized B2B API like Sellsy is painful. Sellsy is not just a simple contact database - it is a full-suite CRM, billing, and accounting platform. Its API reflects that deep operational complexity.

If you decide to build a custom Sellsy MCP server from scratch, here are the specific integration challenges you will face:

Electronic Invoicing Reforms and Strict Schemas Sellsy's accounting modules are built to comply with strict European electronic invoicing reforms. When your AI agent attempts to create or update an invoice, it cannot simply pass arbitrary text. The API enforces strict validation rules - for example, rows [x].tax_id will violently reject non-compliant tax codes, and settings.pdf_display values are often forced to true by the backend. An LLM cannot guess these constraints. Your MCP server must expose strictly defined JSON Schemas that explicitly guide Claude on valid payload structures for financial documents.

Complex Search Filters and Pagination Sellsy does not use simple query parameters for searching records. Endpoints like list_all_sellsy_search_companies or list_all_sellsy_search_invoices require a nested JSON payload containing specific filter objects (e.g., date ranges, archived states, reference arrays). Furthermore, Sellsy relies heavily on pagination limits and offsets. To allow Claude to search effectively, your MCP server must auto-inject pagination instructions (like telling the LLM to pass cursor or offset values back unchanged) and correctly map the complex filter objects into flat MCP tool arguments.

The Custom Field Separation Pattern In Sellsy, custom metadata is not returned or updated alongside standard object fields. If an LLM needs to update a company's custom field, it cannot just PATCH the company endpoint. It must first retrieve the company, then fetch the custom fields via list_all_sellsy_companie_custom_fields, identify the numerical ID of the target field, and finally execute a completely separate sellsy_companie_custom_fields_bulk_update request. Orchestrating this multi-step pattern requires precise tool definitions so the LLM understands the sequence of operations.

The Embedded Relational Model Sellsy makes heavy use of an _embed query parameter to fetch relational data in a single request (e.g., fetching a company and its linked addresses, contacts, and social links). If your MCP tools do not expose these embed options, the LLM will be forced to make dozens of sequential API calls to build a complete profile of a client, burning through rate limits and context windows.

How Truto's Managed MCP Architecture Works

Instead of manually coding JSON-RPC endpoints and maintaining TypeScript tool definitions for Sellsy's massive API surface, Truto derives MCP tools dynamically.

When a customer connects their Sellsy account, Truto automatically generates a set of MCP tools from Sellsy's underlying resource definitions and API documentation. These tools are served over a single JSON-RPC 2.0 endpoint that any MCP client (like Claude Desktop) can connect to.

Each MCP server is scoped to a single integrated account. The server URL contains a cryptographic token that encodes which Sellsy account to use, what tools to expose, and when the server expires. The URL alone is enough to authenticate and serve tools, with no additional configuration needed on Claude's end.

Crucial Factual Note on Rate Limits

When giving AI agents access to Sellsy, rate limiting is a major concern because LLMs can generate bursts of requests during multi-step tool calls. Truto does not retry, throttle, or apply backoff on rate limit errors.

When the upstream Sellsy API returns an HTTP 429 (Too Many Requests), Truto passes that exact error back to the caller (Claude). However, Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller (or the orchestration framework driving the agent) is strictly responsible for inspecting these headers and implementing its own retry and exponential backoff logic.

Step 1: Creating the Sellsy MCP Server

Before Claude can query Sellsy, you must generate an MCP server URL. This URL acts as a secure, scoped gateway to the specific Sellsy tenant. You can create this server via the Truto UI or programmatically via the Truto API.

Method A: Via the Truto UI

This is the fastest method for internal teams and administrators testing Claude integrations.

1. Log into your Truto dashboard and navigate to the Integrated Accounts page.
2. Select the connected Sellsy account you want to expose to Claude.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Configure the server settings (assign a human-readable name, select allowed methods like read or write, and apply any necessary tags).
6. Click Save and copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method B: Via the Truto API

If you are building an application that provisions AI agents dynamically, you should generate MCP servers programmatically.

Make an authenticated POST request to the /integrated-account/:id/mcp endpoint:

curl -X POST https://api.truto.one/integrated-account/YOUR_SELLSY_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Claude Sellsy Integration",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["crm", "accounting"]
    },
    "expires_at": null
  }'

Truto will validate that Sellsy tools are available, generate a secure, hashed token in its KV storage, and return the ready-to-use URL:

{
  "id": "mcp_srv_998877",
  "name": "Claude Sellsy Integration",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}

Step 2: Connecting the MCP Server to Claude

Once you have the Truto MCP URL, you must configure Claude to use it. All communication will happen over HTTP POST using JSON-RPC 2.0 messages.

Method A: Via the Claude UI (or ChatGPT UI)

If you are using enterprise conversational interfaces that support custom UI-based connectors:

1. In your AI interface (e.g., ChatGPT Settings -> Connectors, or Claude Settings -> Integrations), click Add MCP Server or Add Custom Connector.
2. Provide a descriptive name (e.g., "Sellsy CRM & Billing").
3. Paste the Truto MCP URL you generated in Step 1.
4. Click Add. The model will immediately perform an MCP handshake, discovering all available Sellsy tools derived from the integration schemas.

Method B: Via the Claude Desktop Config File

If you are running Claude Desktop locally, you must configure it using the claude_desktop_config.json file. Because Truto's managed MCP servers operate over standard HTTPS using Server-Sent Events (SSE), you use the official @modelcontextprotocol/server-sse package as the command.

Open your configuration file (located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\Claude\claude_desktop_config.json on Windows) and add the Sellsy server:

{
  "mcpServers": {
    "sellsy_production": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f67890"
      ]
    }
  }
}

Restart Claude Desktop. Look for the hammer icon in the input box to confirm that the Sellsy tools have been loaded successfully.

Hero Tools for Sellsy Integrations

Sellsy exposes hundreds of endpoints. Truto automatically maps these into clearly named snake_case tools. Here are six high-leverage hero tools that unlock powerful workflows in Claude.

1. list_all_sellsy_search_companies

This tool allows Claude to search the Sellsy company database using highly structured JSON filter objects. It is the primary entry point for looking up accounts before executing writes.

Usage note: Claude must construct a valid filters object (e.g., searching by reference, email, or creation date). It returns a paginated list of matching companies.

"Search Sellsy for all active companies in the 'Manufacturing' sector that were created in the last 30 days. Return their IDs and primary email addresses."

2. create_a_sellsy_opportunity

This tool creates a new CRM deal (opportunity) linked to a specific company or individual.

Usage note: Requires name, pipeline, step, and the related object payload (which links the opportunity to the target CRM record).

"Create a new Sellsy opportunity for 'Acme Corp Q3 Expansion'. Put it in the 'Enterprise Sales' pipeline at the 'Discovery' step, and link it to company ID 4455."

3. sellsy_opportunitie_custom_fields_bulk_update

Updating custom fields on opportunities requires this specific bulk update endpoint.

Usage note: Claude must supply the opportunity ID and a JSON array of {id, value} pairs, where id is the internal custom field identifier.

"Update the custom fields for opportunity ID 8899. Set the custom field 'Technical Review Complete' (ID: 102) to true, and 'Expected Margin' (ID: 105) to 45000."

4. sellsy_searches_search

This is Sellsy's global free-text search tool. It spans companies, contacts, documents, items, and opportunities.

Usage note: Best used when the LLM only has a vague keyword or name and needs to discover the underlying entity type and exact ID before proceeding with structured operations.

"Perform a global search in Sellsy for the term 'TechFlow Solutions'. Tell me if it exists as a company, contact, or both, and provide the respective IDs."

5. create_a_sellsy_invoice

This tool creates a draft invoice in Sellsy's accounting module.

Usage note: Claude must supply the line items (rows) and document settings. Due to e-invoicing constraints, rows [x].tax_id must reference a compliant tax rate ID.

"Draft a new Sellsy invoice for company ID 2233. Add one line item for 'Annual SaaS License' at 1200 EUR, using tax rate ID 14 (Standard 20%). Leave the status as draft."

6. create_a_sellsy_invoice_validate

Draft invoices cannot be sent or paid until they are validated. This tool transitions an invoice from draft to due.

Usage note: After execution, the invoice becomes immutable in Sellsy. The LLM must explicitly prompt the user for confirmation before calling this tool.

"The draft invoice for Acme Corp looks correct. Go ahead and validate invoice ID 9988 so it is ready for payment collection."

To view the complete schema details and the full inventory of available Sellsy tools, visit the Sellsy integration page.

Workflows in Action

When Claude has access to these tools, it can string them together to handle complex, multi-step business processes autonomously.

Workflow 1: Lead Triage and Deal Pipeline Creation

Sales teams often dump raw research into chat interfaces and ask the AI to update the CRM. Claude must verify if the account exists, update its metadata, and create a deal pipeline.

"Check if 'Globex Corp' exists in Sellsy. If they do, create a new 'Q4 Software Renewal' opportunity for them in the standard pipeline, and assign a task to follow up with them next Tuesday."

Step-by-step Execution:

1. Claude calls sellsy_searches_search with the query q: "Globex Corp" to find the exact company ID.
2. Claude calls create_a_sellsy_opportunity using the retrieved company ID in the related payload.
3. Claude calls create_a_sellsy_task using the due_date calculated for next Tuesday and links it to the newly created opportunity ID.

sequenceDiagram
    participant User
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant Sellsy as "Upstream API (Sellsy)"
    
    User->>Claude: "Check Globex Corp, create deal & task..."
    Claude->>MCP: Call sellsy_searches_search(q="Globex Corp")
    MCP->>Sellsy: GET /v2/search
    Sellsy-->>MCP: Company ID: 5541
    MCP-->>Claude: Company record returned
    Claude->>MCP: Call create_a_sellsy_opportunity(related=5541)
    MCP->>Sellsy: POST /v2/opportunities
    Sellsy-->>MCP: Opportunity ID: 9912
    MCP-->>Claude: Opportunity record returned
    Claude->>MCP: Call create_a_sellsy_task(due_date, related=9912)
    MCP->>Sellsy: POST /v2/tasks
    Sellsy-->>MCP: Task ID: 1104
    MCP-->>Claude: Task created successfully
    Claude-->>User: "I found Globex Corp, created the Q4 deal, and logged your task."

Workflow 2: Automated Quote to Invoice Conversion

Account managers frequently need to manually draft and validate invoices based on accepted proposals. Claude can orchestrate this financial workflow directly from chat.

"Find the accepted estimate for 'Initech' and generate a final invoice for it. Make sure you validate the invoice so it is locked and ready for payment."

Step-by-step Execution:

1. Claude calls list_all_sellsy_search_estimates filtering by company name "Initech" and status "accepted".
2. Claude extracts the related owner data and line items from the estimate response.
3. Claude calls create_a_sellsy_invoice using the exact line items and compliant tax_ids from the estimate.
4. Claude calls create_a_sellsy_invoice_validate using the new invoice ID to finalize the document.

The user receives a direct confirmation that the invoice has been created, validated, and locked in the accounting ledger, complete with the final Sellsy document number.

Security and Access Control

Giving an LLM access to a system that handles both CRM data and live accounting ledgers requires strict governance. Truto's MCP servers provide granular controls when generating the server URL:

• Method Filtering: You can restrict a server to safe operations. Setting methods: ["read"] ensures Claude can execute tools like list_all_sellsy_search_companies but prevents it from using create_a_sellsy_invoice.
• Tag Filtering: Sellsy tools are grouped by tags. You can restrict an MCP server to tags: ["crm"] to completely hide the accounting and billing tools from the LLM, ensuring it cannot access financial data.
• Require API Token Auth: For shared environments, setting require_api_token_auth: true means possession of the URL is not enough. The client must also send a valid Truto API token in the Authorization header to invoke tools.
• Time-Limited Access: Setting an expires_at timestamp creates an ephemeral MCP server. Truto will automatically destroy the token and flush it from KV storage when the time expires - perfect for temporary contractor access or limited-duration agent runs.

Moving Forward with Agentic Sellsy Integrations

Building an AI integration for Sellsy is an exercise in managing complex API constraints. You must orchestrate distinct custom field updates, navigate electronic invoicing requirements, and handle highly nested JSON search filters.

By leveraging Truto's managed MCP servers, you eliminate the need to write and maintain brittle integration code. Truto dynamically maps Sellsy's documentation into standardized JSON-RPC tools, manages the underlying token lifecycles, and normalizes rate limit headers for safe execution.

If you are ready to give your AI agents autonomous, secure access to Sellsy and hundreds of other B2B platforms, you need a robust infrastructure layer.