---
title: "Connect Sellsy to Claude: Query Records and Sync Information"
slug: connect-sellsy-to-claude-query-records-and-sync-information
date: 2026-09-28
author: Yuvraj Muley
categories: ["AI & Agents"]
excerpt: "Learn how to connect Sellsy to Claude using a managed MCP server. A complete engineering guide to generating AI tools, handling custom fields, and querying CRM records."
tldr: "Connect Sellsy to Claude using Truto's managed MCP server. Learn how to dynamically generate AI tools for Sellsy's API, handle complex search filter payloads, manage rate limits, and execute multi-step workflows without writing custom integration code."
canonical: https://truto.one/blog/connect-sellsy-to-claude-query-records-and-sync-information/
---

# 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](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/). 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](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), or use a [managed integration platform](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) 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](https://truto.one/connect-sellsy-to-chatgpt-manage-data-and-automate-workflows/). For a broader architectural overview of agentic workflows, explore our guide on [connecting Sellsy to AI Agents](https://truto.one/connect-sellsy-to-ai-agents-build-autonomous-integration-workflows/).

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.

> Want to give your AI agents secure, authenticated access to Sellsy and 100+ other SaaS APIs? Let's talk about [managed MCP architecture](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/).
>
> [Talk to us](https://truto.one/book-a-demo/)

## 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](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/). 

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:

```bash
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:

```json
{
  "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:

```json
{
  "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](https://truto.one/integrations/detail/sellsy).

## 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.

```mermaid
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_id`s 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.

> Stop writing point-to-point integration code for your AI agents. Let's talk about managed MCP architecture for your SaaS product.
>
> [Talk to us](https://truto.one/book-a-demo/)