Merge Unified's Kintone integration Merge Agent Handler's Kintone MCP server

Connect your AI Agents to Kintone in minutes

Merge lets you securely connect your agents to Kintone and thousands of tools instantly

Start building for free

Read docs

Kintone

Learn more about Merge Agent Handler

Available tools

get_app

Get general information of a Kintone app including name, description, Space, creator and updater info.

get_apps

List Kintone apps with optional filters by IDs, codes, name, or Space IDs. Supports pagination with limit (max 100) and offset parameters.

get_form_fields

Get the list of fields and field settings of a Kintone app. Returns field codes, types, labels, and configuration. Essential for building record queries.

get_form_layout

Get the field layout of a Kintone app form, including row structure, field sizes, and grouping.

get_app_views

Get the list of views (custom views, calendar views, etc.) configured for a Kintone app.

get_record_comments

Get comments on a record. Returns up to 10 comments per request. Use offset for pagination and order (asc/desc) for sorting.

add_record_comment

Add a comment to a record. Comment must include a 'text' key. Optionally include 'mentions' to notify users. Example: {"text": "Hello!", "mentions": [{"code": "user@example.com", "type": "USER"}]}

delete_record_comment

Delete a comment from a record. Only the comment creator or an App admin can delete comments.

upload_file

Upload a file to Kintone. Provide filename and base64-encoded filedata. Returns a fileKey that can be used in record attachment fields. The file is deleted after 3 days if not attached to a record.

get_record

Get a single record from a Kintone app by record ID. Use getapps to find the App ID, then getform_fields to discover field codes.

get_records

Get multiple records from a Kintone app. Supports query filtering, field selection, and pagination via query string (e.g., 'limit 100 offset 0'). Max 500 per request. Use getformfields to discover available field codes for filtering.

add_record

Add a single record to a Kintone app. Record data must use field code keys with value objects. Example: {"Textfield": {"value": "hello"}}. Use getform_fields to discover field codes.

add_records

Add multiple records to a Kintone app in bulk (max 100). Each record uses the same format as add_record. All records are added atomically.

update_record

Update a single record in a Kintone app. Provide the record ID and fields to update. Use revision for optimistic locking (-1 to skip). Use getformfields for field codes.

update_records

Update multiple records in a Kintone app in bulk (max 100). Each item must include "id" and "record" keys. Updates are atomic.

delete_records

Delete records from a Kintone app by IDs (max 100). Optionally provide revision numbers for optimistic locking. This action is permanent.

get_space

Get information about a Kintone Space including name, privacy settings, and member count.

get_space_members

Get the list of members in a Kintone Space, including their roles and permissions.

update_space_body

Update the body content of a Kintone Space. The body accepts HTML content.

validate_credential

Validate Kintone credentials by making a test API call. Returns success status and message.

View all tools by creating a free account See more tools

How to set up Merge Agent Handler

In an mcp.json file, add the configuration below, and restart Cursor.

Learn more in the official documentation ↗

1{
2  "mcpServers": {
3    "agent-handler": {
4      "url": "https://ah-api-develop.merge.dev/api/v1/tool-packs/{TOOL_PACK_ID}/registered-users/{REGISTERED_USER_ID}/mcp",
5      "headers": {
6        "Authorization": "Bearer yMt*****"
7      }
8    }
9  }
10}
11

Copy Code

Open your Claude Desktop configuration file and add the server configuration below. You'll also need to restart the application for the changes to take effect.

Make sure Claude is using the Node v20+.

Learn more in the official documentation ↗

1{
2  "mcpServers": {
3    "agent-handler": {
4      "command": "npx",
5      "args": [
6        "-y",
7        "mcp-remote@latest",
8        "https://ah-api-develop.merge.dev/api/v1/tool-packs/{TOOL_PACK_ID}/registered-users/{REGISTERED_USER_ID}/mcp",
9        "--header",
10        "Authorization: Bearer ${AUTH_TOKEN}"
11      ],
12      "env": {
13        "AUTH_TOKEN": "yMt*****"
14      }
15    }
16  }
17}

Copy Code

Open your Windsurf MCP configuration file and add the server configuration below.
Click on the refresh button in the top right of the Manage MCP server page or in the top right of the chat box in the box icon.

Learn more in the official documentation ↗

1{
2    "mcpServers": {
3      "agent-handler": {
4        "command": "npx",
5        "args": [
6          "-y",
7          "mcp-remote@latest",
8          "https://ah-api.merge.dev/api/v1/tool-packs/<tool-pack-id>/registered-users/<registered-user-id>/mcp",
9          "--header",
10          "Authorization: Bearer ${AUTH_TOKEN}"
11        ],
12        "env": {
13          "AUTH_TOKEN": "<ah-production-access-key>"
14        }
15      }
16    }
17  }

Copy Code

In Command Palette (Cmd+Shift+P on macOS, Ctrl+Shift+P on Windows), run "MCP: Open User Configuration".

You can then add the configuration below and press "start" right under servers. Enter the auth token when prompted.

Learn more in the official documentation ↗

1{
2  "inputs": [
3    {
4      "type": "promptString",
5      "id": "agent-handler-auth",
6      "description": "Agent Handler AUTH_TOKEN", // "yMt*****" when prompt
7      "password": true
8    }
9  ],
10  "servers": {
11    "agent-handler": {
12      "type": "stdio",
13      "command": "npx",
14      "args": [
15        "-y",
16        "mcp-remote@latest",
17        "https://ah-api-develop.merge.dev/api/v1/tool-packs/{TOOL_PACK_ID}/registered-users/{REGISTERED_USER_ID}/mcp",
18        "--header",
19        "Authorization: Bearer ${input:agent-handler-auth}"
20      ]
21    }
22  }
23}

Copy Code

FAQs on using Merge's Kintone MCP server

What is a Kintone MCP?

It's an MCP server that connects your agents to Kintone's low-code business application platform via tools. Your agents can invoke these tools to read and write records across apps, post comments, retrieve app and form configurations, upload files, and more.

Kintone offers an official MCP server, but you can also use one from a third-party platform, like Merge Agent Handler.

How can I use the Kintone MCP server?

The use cases naturally depend on the agent you've built, but here are a few common ones:

Automated record intake from external sources: When a customer request arrives via a web form or email tool, an agent creates a corresponding record in a Kintone app, populates the relevant fields, and notifies the responsible team member

Cross-system data sync: When a project status changes in a project management tool, an agent finds the corresponding Kintone record and updates its fields to keep both systems aligned without manual re-entry

Record annotation from approval workflows: When a document is approved in a signing or review tool, an agent posts a comment to the relevant Kintone record with the approval decision, approver name, and timestamp

App-level reporting for operations teams: On a weekly schedule, an agent queries records across one or more Kintone apps, filters by status or date range, and formats a summary that gets posted to a Slack channel or sent as an email digest

What are popular tools for Kintone's MCP server?

Here are some of the most commonly used tools:

get_records: retrieves records from a Kintone app with support for filtering and pagination. Use this when an agent needs to pull data from a business app for reporting, processing, or cross-referencing with records in another system

add_record: creates a new record in a specified Kintone app with field values supplied by the agent. Call this when an agent is capturing data from an external trigger like a form submission, webhook, or scheduled data pull

update_record: modifies the fields of an existing Kintone record. Good for workflows that keep Kintone in sync with status changes or enrichment data arriving from another tool

add_record_comment: posts a comment to a specific Kintone record. Helpful when an agent needs to log an event, decision, or note directly on the record where the relevant team members will see it

get_form_fields: returns the field definitions and types for a Kintone app's form. Use this when an agent needs to understand a form's structure before constructing records or validating incoming data against expected fields

get_apps: lists the apps available in a Kintone environment with their IDs and names. Useful for agents navigating environments with many apps that need to identify the correct target before querying or writing records

What makes Merge Agent Handler's Kintone MCP server better than alternative Kintone MCP servers?

Kintone has an official MCP server, but Merge Agent Handler adds controls that matter when Kintone is managing real business data in production:

Enterprise-grade security and DLP: Merge Agent Handler includes built-in data loss prevention controls that let you block or redact sensitive fields before they reach an agent. For Kintone, this means you can prevent record contents, form field structures, and workspace data from being exposed to agents that don't specifically require them

Managed authentication and credentials: Merge stores and manages your Kintone credentials on your behalf. You never pass usernames, passwords, or API tokens directly into agent configuration or rebuild your auth setup when credentials change

Real-time observability and audit trail: Every tool call against Kintone is captured with timestamp, tool name, app target, and response data. Operations and compliance teams can see exactly which records an agent read or modified without writing any custom logging

Tool Packs and controlled access: Tool Packs let you bundle specific Kintone tools with tools from other connectors into a single MCP endpoint, scoped to a specific use case. An agent gets exactly the tools it needs, nothing more

How can I start using Merge Agent Handler's Kintone MCP server?

You can take the following steps:

1. Create or log into your Merge Agent Handler account and navigate to Tool Packs (collections of connector tools scoped to a specific use case).

2. Create a new Tool Pack, then find and enable the Kintone connector. Scope tools to your workflow: get_records and get_apps cover read and discovery needs, while add_record, update_record, and add_record_comment are needed for agents that write to Kintone apps.

3. Add a Registered User inside the Tool Pack. This is the identity context under which your agent operates. Merge generates a unique MCP URL scoped to this user once it's created.

4. From the Registered User detail page, authenticate Kintone by entering your credentials. Merge stores and manages those credentials going forward.

5. Copy the MCP URL from the Tool Pack detail page and generate an API key from Settings. You'll need both to connect your agent.

6. Add the MCP server to your agent or IDE using the MCP URL and API key. Your Kintone tools are now accessible through that endpoint.