Getting Started with Kintsugi MCP

Kintsugi's Model Context Protocol (MCP) integration transforms how developers build with our tax compliance API. Instead of manually reading documentation and writing API calls, AI assistants can understand Kintsugi's endpoints, generate accurate code, debug issues, and provide context-aware help, all while you code.

Why Use Kintsugi MCP?

Building integrations with Kintsugi's API typically requires:

• Reading extensive API documentation
• Understanding request/response formats
• Handling authentication correctly
• Debugging API errors
• Writing boilerplate code

With MCP-enabled AI assistants, you get:

• Accurate Code Generation - AI understands Kintsugi's actual API endpoints and generates working code
• Real-Time Documentation - AI assistants access up-to-date API specs, not outdated docs
• Context-Aware Help - Get suggestions based on your actual code and integration needs
• Faster Development - Reduce time spent on API integration from hours to minutes

How It Works

Here's how Kintsugi MCP helps you build better integrations:

Quick Setup

{
  "mcpServers": {
    "kintsugi": {
      "url": "https://docs.trykintsugi.com/mcp",
      "headers": {
        "X-API-KEY": "your-api-key",
        "X-ORGANIZATION-ID": "your-org-id"
      }
    }
  }
}

What the tools can do

Each tool maps to one Customer API operation and is named after its reference page, so create-transaction the tool and /reference/create-transaction the page are always the same operation.

The tools do not only describe the API, they call it, with the key from your connection headers. That means 17 of the 41 change your data: creating a transaction or a credit note, updating a customer, deregistering a registration, deleting a physical nexus.

The other 24 only read. That includes three that are POST requests but commit nothing, because they take a request body rather than because they save anything: estimate-tax, search and suggestions.

Read-only operations (anything beginning get-) only fetch. Kintsugi validates every call against the published schema before it reaches the API, and any error the API returns is passed back to you unchanged.

Available API Endpoints

Kintsugi MCP on the public docs site exposes endpoints from the public API Reference only (the Customer API). Partner APIs are not included.

Real-World Example

Here's a complete example of building a checkout integration with MCP:

Developer: "I need to add tax calculation to my e-commerce checkout. How do I integrate with Kintsugi?"

AI Assistant (with Kintsugi MCP):

1. Understands the requirement - Needs tax calculation in checkout flow
2. Identifies the endpoint - POST /v1/tax/estimate from Kintsugi's API
3. Generates code:

   import requests
   
   def calculate_tax(cart_total, shipping_address, api_key, organization_id):
       response = requests.post(
           'https://api.trykintsugi.com/v1/tax/estimate',
           headers={
               'x-api-key': api_key,
               'x-organization-id': organization_id,
               'Content-Type': 'application/json'
           },
           json={
               'amount': cart_total,
               'shipping_address': {
                   'street_1': shipping_address['street'],
                   'city': shipping_address['city'],
                   'state': shipping_address['state'],
                   'zip': shipping_address['zip']
               }
           }
       )
       response.raise_for_status()
       return response.json()

4. Explains next steps - How to handle the response, error cases, and commit the transaction

Result: Developer has working code in minutes instead of hours of API documentation reading.

Benefits for Developers

Next Steps