Skip to main content
What is MCP? Model Context Protocol (MCP) enables AI coding assistants like Claude in Cursor IDE to understand and use external APIs. Kintsugi’s MCP server gives AI assistants direct access to our API documentation, making it easier for developers to build integrations with accurate, up-to-date code examples.
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
You: “How do I calculate tax for a checkout using Kintsugi?”AI Assistant (with Kintsugi MCP):
  • Understands the /v1/tax/estimate endpoint
  • Generates code with correct request format
  • Includes proper authentication headers
  • Handles response parsing
Result: You get working code to integrate tax calculation into your checkout flow.
You: “My tax calculation is failing with a 400 error”AI Assistant (with Kintsugi MCP):
  • Tests the same endpoint with your parameters
  • Identifies missing required fields
  • Suggests fixes based on current API requirements
  • Provides corrected code
Result: Fast resolution instead of manual API debugging.
You: “How do I handle tax-exempt customers in my integration?”AI Assistant (with Kintsugi MCP):
  • Explains exemption endpoints
  • Shows how to link exemptions to transactions
  • Generates code for the complete workflow
  • Provides best practices
Result: Complete understanding and implementation in one conversation.

​
How It Works

Here’s how Kintsugi MCP helps you build better integrations:
You ask an AI assistant: “How do I call Kintsugi’s tax estimation endpoint?”
The AI assistant queries Kintsugi’s MCP server, which provides access to our OpenAPI specification with all endpoint details.
The MCP server gives the AI context about:
  • Available endpoints (like POST /v1/tax/estimate)
  • Request/response schemas
  • Authentication requirements
  • Error handling patterns
Based on the API spec, the AI generates working code:
import requests

response = requests.post(
    'https://api.trykintsugi.com/v1/tax/estimate',
    headers={
        'x-api-key': 'your-api-key',
        'x-organization-id': 'your-org-id'
    },
    json={
        'amount': 100.00,
        'shipping_address': {...}
    }
)
You integrate the generated code into your application, customize it for your needs, and start making API calls.

​
Quick Setup

1

Choose Your Development Environment

Kintsugi MCP works with MCP-compatible AI coding assistants:
  • Cursor IDE
  • Claude Desktop
  • VS Code with MCP Extension
Cursor’s AI assistant can use MCP servers, making it perfect for developers building Kintsugi integrations. The AI understands your codebase and Kintsugi’s API simultaneously.
2

Configure MCP Server

Add Kintsugi’s MCP server to your AI assistant configuration:
{
  "mcpServers": {
    "kintsugi": {
      "url": "https://docs.trykintsugi.com/mcp"
    }
  }
}
3

Get Your API Key & Organization ID

You’ll need both an API key and Organization ID for authentication:
  1. Sign in to app.trykintsugi.com
  2. Navigate to Settings → API Keys
  3. Create a new API key
  4. Store it securely (never commit to version control)
  5. Find your Organization ID in the lower left-hand corner of the dashboard after logging in
4

Start Building

Once configured, your AI assistant understands Kintsugi’s API. Try asking:
  • “Show me how to estimate tax for a transaction”
  • “Generate code to create a customer in Kintsugi”
  • “How do I handle address validation?”
  • “What’s the request format for creating a registration?”

​
Available API Endpoints

Kintsugi MCP exposes all endpoints from our API Reference - Partners section, giving AI assistants knowledge of:

Tax Estimation

POST /v1/tax/estimate - Calculate tax for transactions before committing

Transaction Management

POST /v1/transactions, GET /v1/transactions - Create and manage sales transactions

Customer Management

POST /v1/customers, GET /v1/customers/{id} - Manage customer records and exemptions

Nexus & Registrations

GET /v1/nexus, POST /v1/registrations - Determine nexus and manage registrations

Products & Categories

POST /v1/products, GET /v1/product-categories - Manage product taxability

Filings & Compliance

GET /v1/filings, POST /v1/filings - Track and manage tax filings

Address Validation

POST /v1/address_validation/search - Validate addresses for accurate tax calculation

Organization Management

GET /v1/organizations, POST /v1/api-keys - Manage organization settings

​
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

Faster Integration

Reduce integration time from days to hours with AI-generated code

Fewer Errors

AI understands API schemas and generates correct request formats

Always Up-to-Date

MCP provides current API specs, not outdated documentation

Better Debugging

AI can test endpoints and identify issues faster than manual debugging

​
Next Steps

Explore Use Cases

See how developers use Kintsugi MCP in real projects

Integration Guide

Step-by-step setup for your development environment

Browse API Endpoints

View all endpoints available through MCP

Full API Reference

Complete API documentation
Authentication Required - While the MCP server helps AI assistants understand Kintsugi’s API, you’ll still need valid API credentials to make actual API calls.Kintsugi uses API key authentication via headers (not bearer token). Every request requires:
  • x-api-key header with your API key
  • x-organization-id header with your organization ID
Generate API keys in your Kintsugi dashboard. Your Organization ID can be found in the lower left-hand corner after logging in.