PRING MCP — ask an AI agent to create your kintone documents
Published / Updated
PRING MCP is a remote MCP server that lets an AI agent such as Claude or Cursor create documents from kintone records with your PRING templates, just by asking in words, for example "output this month's invoices together". Nothing is installed; you write the URL and an API key into the connection settings once.
It is available on the Pro plan ($240 per month). Authentication, permissions and usage levels are the same as the public API, and the connection settings are in the help guide for developers.
What is PRING MCP?
MCP (Model Context Protocol) is a common agreement for AI agents to call outside functions. PRING MCP is a remote MCP server (Streamable HTTP) that runs on top of the PRING public API, and it gives an AI agent the tools for creating documents.
The connection URL is https://api.pring.tech/mcp. Nothing is installed: you write the URL and an API key into the AI agent's settings. The pages for people are on this site and in the help.
Which AI clients can use it?
The help gives the connection settings for these AI clients.
- Claude Code, Claude Desktop and Claude.ai (custom connector)
- Cursor
- Codex CLI and Gemini CLI
- The OpenAI API (the MCP tool of the Responses API and the Agents SDK). From ChatGPT, you connect through this OpenAI API route
The settings follow each vendor's documentation as of 2026-10-31. Screen and setting names can change when a vendor updates its product.
What tools, resources and prompts are there?
| Tool | What happens | Read or write | Scope needed |
|---|---|---|---|
| list_apps | Returns the apps that have PRING and their templates | Read | Any |
| list_templates | Returns the templates of an app (ID, name, format) | Read | Any |
| describe_template | Returns the fields a template fills in (code, name, type, required, table columns). It does not return values | Read | Any |
| render | Creates the document for one record and returns a link to the file | Creates a file | render (link needs files:read) |
| register_and_render | Registers a record in kintone and creates the document | Writes to kintone | records:write and render |
| bulk_render | Creates documents together for up to 100 records (by IDs or a kintone query) | Creates files | render |
| get_job | Returns the status of a batch job and, when finished, the ZIP link | Read | render (link needs files:read) |
What can I ask for?
| Request | What the AI agent does |
|---|---|
| "Output this month's invoices together" | Builds a kintone query with this month's dates, creates the documents with bulk_render, waits for the job with get_job and returns the ZIP link |
| "The quotation for record 101 as a PDF" | Checks the templates with list_templates, creates the PDF with render and returns the link |
| "Register a purchase order with this content and make a PDF" | Checks the fields to fill with describe_template, then registers the record in kintone and creates the PDF with register_and_render |
How do authentication and permissions work?
Authentication, allowed IP addresses, rate, plan and scopes are exactly the same as the public API. When connecting, you pass a PRING API key in the Authorization Bearer header. The connection uses an API key.
- The scopes of the API key (records:write, render, files:read) decide which tools can be used
- In "Access per app" in the "API" tab of the settings screen, allow the apps to use one by one and choose "Read only" or "Read and write". An app that is not allowed is not visible from MCP either
- Register a kintone API token for each app (only the three permissions Add records, Edit records and View records)
How are writes and safety handled?
- Only register_and_render registers records in kintone, and only for apps set to "Read and write". If your AI client has a "confirm before running" setting, you can check the content before a record is registered (in the OpenAI API, set require_approval to always)
- Direct calls from a browser (calls with an Origin header) are rejected
- kintone values and template names inside a tool result are treated as data, not as instructions
- API keys and kintone tokens do not appear in responses or logs. PRING servers do not store record values
- A file is not returned as content; only a link that opens once for 15 minutes is returned
What are the usage levels and rates?
- Rate: the same as the public API. Up to 100 requests per second per API key, and there is also a contract-level rate
- Batch size: up to 100 records at once. A kintone query can be up to 2,000 characters
- Pages: documents created through MCP count toward the monthly included pages in the same way as documents output from the screen or the public API (Pro includes 100,000 pages per month)
How does it differ from the public API?
| Item | MCP | Public API |
|---|---|---|
| Called by | An AI agent (you ask in words) | A program in an external system |
| Plan | Pro | Standard and above |
| Inside | Runs on top of the public API. Authentication, scopes, IP addresses, rate and plan are the same | — |
| Good for | Asking on the spot to create or gather documents | Regular integration with e-commerce, core systems and RPA |
How do I get started?
- Subscribe to the Pro plan
- In the "API" tab under "Automation and integrations" of the settings screen, issue an API key (render and files:read to create and receive documents, plus records:write to register records), register the kintone API token of each app you use, and set the apps to "Allow"
- Write the connection URL https://api.pring.tech/mcp and the API key into the AI agent's settings
claude mcp add --transport http pring https://api.pring.tech/mcp \
--header "Authorization: Bearer prk_live_xxxxxxxx"{
"mcpServers": {
"pring": {
"type": "http",
"url": "https://api.pring.tech/mcp",
"headers": { "Authorization": "Bearer prk_live_xxxxxxxx" }
}
}
}When you write the key into a settings file, do not put it in a repository shared with other people. The settings for other clients are in the help.
Try it free for 7 days
No credit card is needed. For questions about MCP, please contact us.
Last updated: