Connect Sellsy to ChatGPT: Manage Data and Automate Workflows

If you want to connect Sellsy to ChatGPT to automate CRM data entry, manage complex invoicing lifecycles, and coordinate your sales pipelines, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's JSON-RPC tool calls 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 Claude, check out our guide on connecting Sellsy to Claude or explore our broader architectural overview on connecting Sellsy to AI Agents.

Giving a Large Language Model (LLM) read and write access to a comprehensive ERP and CRM suite like Sellsy is a massive engineering challenge. You have to handle complex relational payloads, polymorphic links between entities, and incredibly strict validation rules mandated by European electronic invoicing laws. Every time a developer adds a new custom field to a Sellsy opportunity, your custom server code must be updated, redeployed, and tested so the LLM knows it exists.

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

Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds. :::

Sellsy to ChatGPT Quickstart Guide

If you just want the fastest path from a fresh Truto account to ChatGPT calling the Sellsy API, follow these steps.

What you need:

• A Truto account with API access.
• A Sellsy admin account to authorize the OAuth consent flow.
• A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode available.

Step 1: Connect Sellsy to Truto

In the Truto dashboard, open Integrated Accounts -> New Integrated Account, select Sellsy, and run the OAuth flow. Truto securely manages the OAuth lifecycle, storing the refresh token and automatically refreshing access tokens shortly before they expire. Your ChatGPT agent will never fail a tool call due to an expired bearer token.

Step 2: Grab your Integrated Account ID

You can copy the integrated_account_id directly from the account detail page in the Truto UI, or list it via the API:

curl https://api.truto.one/integrated-account \
  -H "Authorization: Bearer $TRUTO_API_TOKEN"

Step 3: Generate the Sellsy MCP Server URL

Truto creates an isolated MCP endpoint scoped specifically to this connected Sellsy account. You can do this via the UI or the API.

Via the Truto UI:

1. Navigate to the integrated account page for your Sellsy connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., filtering to specific tags like "invoicing" or restricting to "read" methods).
5. Copy the generated MCP server URL.

Via the API: Run a POST request to generate the server URL programmatically, applying filters to constrain what ChatGPT can touch:

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Sellsy for ChatGPT",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["crm", "invoicing", "catalog"]
    }
  }'

The response returns a url field (e.g., https://api.truto.one/mcp/<token>). Treat this URL as a secret - it carries routing and authentication context for the specific Sellsy account.

Step 4: Register the MCP Server with ChatGPT

You can connect this URL to ChatGPT either directly in the interface or via a local configuration file for programmatic agent setups.

Via the ChatGPT UI:

1. In ChatGPT, navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode.
3. Under MCP servers / Custom connectors, click Add new server.
4. Set the Name to "Sellsy (Truto)".
5. Paste the Truto MCP URL into the Server URL field and click Add.

Via Manual Config File (for headless agents or local testing): If you are running a custom OpenAI-compatible agent framework locally, you can use the standard Model Context Protocol SSE proxy. Create an mcp.json config file:

{
  "mcpServers": {
    "sellsy": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/your-secure-token-here"
      ]
    }
  }
}

ChatGPT will immediately parse the dynamically generated JSON Schema for Sellsy's endpoints and surface them as callable tools.

The Engineering Reality of the Sellsy API

Building a custom MCP server requires deep knowledge of the underlying API's idiosyncrasies. If you decide to write custom schemas for Sellsy instead of using Truto's dynamically generated tools, you must handle several highly specific architectural quirks.

The French E-Invoicing Mandate

Sellsy is heavily utilized by European businesses and rigorously enforces European electronic invoicing compliance directly at the API layer. When an LLM attempts to create or update an invoice, Sellsy's API rejects line items (rows) if the tax_id does not point to a strictly compliant tax rate. Furthermore, document settings parameters like pdf_display are forcefully overridden to true by the API for certain document types to comply with audit trails. If your MCP server's JSON Schema doesn't strictly guide the LLM to provide compliant tax IDs, the LLM will repeatedly fail to draft invoices.

Polymorphic "Related" Entities

Unlike a standard REST API where a comment belongs to a /tickets/:id/comments endpoint, Sellsy relies heavily on polymorphic associations. Objects like tasks, emails, and custom activities use a related object to link to a parent entity (a company, an individual, an opportunity, or a document). The LLM must be explicitly instructed on how to structure this related object depending on the context, otherwise it will create orphaned records.

Custom Field Bulk Updates

Sellsy handles custom fields differently than most CRMs. Instead of a flat key-value object on the main entity payload (e.g., {"custom_industry": "Tech"}), Sellsy requires hitting a dedicated bulk update endpoint (like sellsy_opportunitie_custom_fields_bulk_update). This endpoint expects a bare JSON array of {id, value} pairs, where the id is the internal ID of the custom field definition, and the value must exactly match the expected primitive type (text, numeric, date, choice ID).

Truto's documentation-driven MCP generation automatically parses these complex requirements from Sellsy's schema definitions and injects explicit instructions into the LLM prompt context, drastically reducing hallucinations.

Sellsy Hero Tools for AI Agents

When you connect Sellsy via Truto, dozens of operations are instantly translated into MCP tools. Here are the highest-leverage tools for automating CRM and ERP workflows via ChatGPT.

Search Invoices

Tool name: list_all_sellsy_search_invoices

Allows the LLM to query financial records using complex filters. Because Sellsy's search endpoints use a POST body for filter criteria, this tool lets ChatGPT find unpaid invoices, filter by specific date ranges, or locate documents tied to specific owners.

"Find all draft invoices created this week for the client 'Acme Corp' and tell me their total amounts."

Create Company

Tool name: create_a_sellsy_company

The foundation of CRM automation. This tool lets ChatGPT ingest unstructured text - like meeting notes or a web scrape - and structure it into a formal Sellsy company record, applying the correct type (client, prospect, supplier) and extracting contact details.

"I just got an email from Jane Doe at Initech. They are a new prospect based in Texas. Create a new prospect company record for Initech in Sellsy, using their main phone number from her signature."

Update Opportunity Custom Fields

Tool name: sellsy_opportunitie_custom_fields_bulk_update

Because custom fields define your unique sales methodology (e.g., MEDDIC criteria, technical requirements), updating them is critical. This tool accepts the exact JSON array format Sellsy demands, allowing ChatGPT to enrich deals dynamically.

"Update the opportunity for the 'Project Alpha' deal. Set the custom field 'Technical Review Complete' to true, and update the 'Estimated ARR' field to 50000."

Create and Attach Invoice File

Tool name: create_a_sellsy_invoice_file

Sellsy supports multipart/form-data file uploads. Truto handles the complex multipart boundary encoding automatically, allowing ChatGPT to attach context files (like external purchase orders or signed contracts) directly to Sellsy financial documents.

"Attach the finalized vendor MSA PDF to invoice number INV-2023-0045."

Validate Invoice

Tool name: create_a_sellsy_invoice_validate

Sellsy enforces strict state machines on financial documents. An invoice starts as a draft, but must be "validated" to move to a due state. Once validated, it becomes immutable to comply with accounting standards. ChatGPT can use this tool to finalize a drafted invoice after human review.

"The client just approved the draft quote over email. Go ahead and validate the corresponding draft invoice so we can send it for payment."

Create Deposit Invoice

Tool name: create_a_sellsy_deposit_invoice

For service-based businesses, billing often requires upfront deposits. This tool allows the LLM to generate a deposit invoice linked to a parent document (like an accepted order), calculating the percentage automatically.

"We just closed the Acme software deployment deal. Generate a 50% deposit invoice linked to their accepted order so we can collect the upfront payment."

To view the complete inventory of available proxy operations and JSON schemas, visit the Sellsy integration page.

Workflows in Action

AI agents excel at orchestrating multi-step API workflows that normally require a human to click through multiple tabs in the Sellsy dashboard. Here is how ChatGPT utilizes these tools in practice.

Scenario 1: Autonomous Quote-to-Cash Orchestration

When a sales rep closes a deal, administrative work piles up. An AI agent can monitor an inbox for deal approvals and handle the entire financial setup in Sellsy.

"The client approved the 'Q3 Enterprise Deployment' proposal via email. Please finalize the paperwork and get the initial deposit invoice ready."

1. list_all_sellsy_search_opportunities: ChatGPT searches the CRM to find the specific opportunity based on the proposal name and client email.
2. create_a_sellsy_model_convert: The agent converts the accepted Sellsy document model (the proposal) into a draft order, carrying over the line items and tax data.
3. create_a_sellsy_deposit_invoices_quick_create: Knowing the standard terms dictate a 50% upfront payment, ChatGPT immediately generates a deposit invoice against the newly created order.
4. create_a_sellsy_invoice_validate: The agent validates the deposit invoice, locking it into the ledger and making it ready for client payment.

sequenceDiagram
    participant User as User (via ChatGPT)
    participant LLM as ChatGPT
    participant Truto as Truto MCP Server
    participant Sellsy as Sellsy API

    User->>LLM: "Client approved 'Q3 Enterprise'. Generate 50% deposit."
    LLM->>Truto: Call list_all_sellsy_search_opportunities
    Truto->>Sellsy: POST /opportunities/search
    Sellsy-->>Truto: Return Opp ID
    Truto-->>LLM: Opp data
    
    LLM->>Truto: Call create_a_sellsy_model_convert
    Truto->>Sellsy: POST /models/{id}/convert (Order)
    Sellsy-->>Truto: Draft Order created
    Truto-->>LLM: Order ID
    
    LLM->>Truto: Call create_a_sellsy_deposit_invoices_quick_create
    Truto->>Sellsy: POST /deposit-invoices/quick-create
    Sellsy-->>Truto: Draft Deposit Invoice created
    Truto-->>LLM: Invoice ID
    
    LLM->>Truto: Call create_a_sellsy_invoice_validate
    Truto->>Sellsy: POST /invoices/{id}/validate
    Sellsy-->>Truto: Invoice Status: Due
    Truto-->>LLM: Success
    LLM-->>User: "Deposit invoice created and validated."

Scenario 2: CRM Enrichment from Unstructured Data

Sales teams hate manual data entry. ChatGPT can parse raw meeting transcripts or call notes and structure them perfectly into Sellsy's relational model.

"I just had a great discovery call with GlobalTech. Here is the raw transcript. Create a company record for them, add a summary note of the call, and flag the deal size as $100k."

1. create_a_sellsy_company: ChatGPT parses the transcript to identify the company name, industry, and contact details, passing them into the strict CRM schema.
2. create_a_sellsy_opportunity: The agent creates a new pipeline opportunity, linking it to the newly created company ID via the related polymorphic object.
3. sellsy_opportunitie_custom_fields_bulk_update: The agent maps the "$100k" deal size to the specific deal_value custom field ID, formatting the bulk update array correctly.
4. create_a_sellsy_comment: Finally, the agent summarizes the massive transcript into a concise paragraph and posts it to the Sellsy comment stream for the opportunity.

Handling Sellsy Rate Limits

When automating workflows at speed, your AI agent will inevitably bump into API rate limits.

It is critical to understand that Truto does not automatically retry, throttle, or apply backoff logic on rate limit errors. If ChatGPT fires too many concurrent tool calls and Sellsy returns an HTTP 429 (Too Many Requests), Truto passes that 429 error directly back to the caller.

However, Truto normalizes Sellsy's proprietary rate limit headers into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). This allows the MCP client or the LLM orchestration framework to read the exact timestamp of when the limit resets, and gracefully pause execution before retrying the tool call.

Security and Access Control

Handing an LLM unrestricted read and write access to your financial ERP and CRM is incredibly risky. Truto's MCP architecture provides granular access controls at the token level, ensuring your agent only has the permissions it strictly requires.

• Method Filtering: Limit the server to safe operations. By passing "methods": ["read"] during creation, you guarantee the LLM can only query data, never update, delete, or validate invoices.
• Tag Filtering: Restrict access to specific functional areas. Using "tags": ["crm"] ensures the LLM can manage companies and contacts, but has zero visibility into "invoicing" or "accounting_codes".
• API Token Authentication: By enabling require_api_token_auth: true, possession of the MCP URL is no longer enough. The client must also present a valid Truto API token, adding a secondary layer of enterprise security.
• Time-Bound Access: Generate short-lived agent sessions by setting an expires_at timestamp. Once expired, the underlying KV storage automatically purges the token, severing the LLM's connection instantly.

By combining dynamic tool generation with rigorous, token-level access controls, you can connect Sellsy to ChatGPT in minutes, safely unlocking agentic automation for your most critical business operations.