Kintone connector for AI agents

Tools your operations agent reaches for on Kintone, scoped per user.

CALL ANY TOOL

33 tools for business apps in Kintone: query, create, update, and delete records, batch up to 100 at once, post comments, run process management actions, export large sets with cursors, and read app forms, views, and permissions.

kintone_app_actions_get

Get app actions

Get a Kintone app's action settings (buttons that copy a record into another app). Returns each action with its destination app, field mappings and who can use it. Use it to understand cross-app record copying. Use kintone_app_process_management_get for workflow actions.

Parameters

Name

Type

Required

Description

app

integer

Required

ID of the Kintone app. It is the number after /k/ in the app's URL, for example 42 in https://mycompany.kintone.com/k/42/. The connection's API token must belong to this app. Example: 42.

lang

string

Optional

Language for localized names in the response: default (names as entered), en, zh, ja, or user (the authenticating user's language). Kintone returns default names if left empty. Example: "en". One of: `default`, `en`, `zh`, `ja`, `user`.

kintone_app_admin_notes_get

Get app admin notes

kintone_app_field_permissions_get

Get app field permissions

kintone_app_form_fields_get

Get app form fields

kintone_app_form_layout_get

Get app form layout

kintone_app_get

Get app

kintone_app_graphs_get

Get app graphs

kintone_app_per_record_notifications_get

Get app per record notifications

kintone_app_permissions_get

Get app permissions

kintone_app_plugins_get

Get app plugins

kintone_app_record_permissions_get

Get app record permissions

kintone_app_reminder_notifications_get

Get app reminder notifications

kintone_app_settings_get

Get app settings

kintone_app_views_get

Get app views

kintone_bulk_request

Bulk request

kintone_record_assignees_update

Update record assignees

kintone_record_comment_create

Create record comment

kintone_record_comment_delete

Delete record comment

kintone_record_comments_list

List record comments

kintone_record_create

Create record

kintone_record_get

Get record

kintone_record_status_update

Update record status

kintone_record_update

Update record

kintone_records_create

Create records

kintone_records_cursor_create

Create records cursor

kintone_records_cursor_delete

Delete records cursor

kintone_records_delete

Delete records

kintone_records_list

List records

kintone_records_statuses_update

Update records statuses

kintone_records_update

Update records

For more tools, view docs.

Build your Agent

Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.

import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// Kintone tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["kintone"], toolNames: [
    "kintone_records_list",
    "kintone_record_comment_create",
    "kintone_record_status_update"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Review purchase requests awaiting approval and comment on each" }] });

import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["kintone"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "Review purchase requests awaiting approval and comment on each" }],
  tools,
});

// Execute the tool call with the user's vaulted Kintone API key
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");

import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["kintone"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Review purchase requests awaiting approval and comment on each" }],
  tools,
});

// Tool call runs with the user's vaulted Kintone API key
await sk.tools.executeTool(msg.content, "user_123");

import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["kintone"] }, pageSize: 100,
});

const agent = new Agent({
  name: "operations_agent",
  model: "gemini-2.5-pro",
  instruction: "Kintone tools scoped to this user",
  tools,
});

await agent.run("Review purchase requests awaiting approval and comment on each");

Try these prompts

Copy any prompt into your agent. Each maps directly to a Kintone tool. Click to copy, paste into your agent, done.

Records

Copy the prompt

Copied

List purchase requests where Status is Awaiting Approval.

Copy the prompt

Copied

Create a record in the Customer Inquiries app for Acme about delivery dates.

Copy the prompt

Copied

Update record 128 in Deals to set Stage to Won.

Process and comments

Copy the prompt

Copied

Approve record 57 in the Purchase Requests app.

Copy the prompt

Copied

Assign record 57 to Maria for the next step.

Copy the prompt

Copied

Comment on record 128 that the contract was signed today.

App setup

Copy the prompt

Copied

Show the form fields of the Deals app.

Copy the prompt

Copied

List the record views in the Customer Inquiries app.

Copy the prompt

Copied

Who has permission to edit records in the Deals app?

SEE HOW AUTH WORKS

Each user connects their own Kintone API key once, and Scalekit sends it with every call. API keys stay vaulted, every call is scope checked, and every action is logged.

Authorize

Your user connects

Kintone

once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access

Who:

user ‘A’

when:

Once per user

access:

Limited to user

Store

Their

Kintone

token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection

vault:

encrypted

scope:

per-user

tokens:

auto-refreshed

Resolve

When your agent calls a

Kintone

tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs

speed:

~40ms

check:

before every call

seen by:

nobody

Audit

Every

Kintone

tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it

history:

90 days

export:

SIEM-ready

logged:

every call

Test other agents

See the same per-user auth pattern across other database and productivity connectors.

GTM and RevOps Teams

CRM AI agent

Reads the Granola transcript after every call, extracts next steps and updates the HubSpot record, drafts the follow-up in Gmail, and confirms in Slack, all on the rep's own delegated OAuth.

GTM and RevOps Teams

Deal room sync

Pulls opportunity context from Salesforce, captures key decisions from Slack, and syncs a running summary to the deal room doc in Google Drive, but only when the deal actually changed.

Why Scalekit

Secure your agent's access. Connectors ship in minutes

01.

Shared tokens break per-user analytics

A shared Kintone API key looks fine in a demo. In production every record update and approval looks like one service account, and you cannot tell which user triggered it. Scalekit resolves the credential of the actual user who triggered the agent, never a shared bot.

// shared key
audit → bot_service_account

// scalekit
audit → user_abc ✓

02.

Authentication is not authorization

03.

Multi-tenancy is architectural

04.

Kintone today. Ten connectors tomorrow.

“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”

Venu Madhav Kattagoni

Head of Engineering / Von

FAQs

Frequently Asked Questions

Does the agent access Kintone as the user or through a shared API key?

As the user. Each user connects their own Kintone API key once, and Scalekit sends it with every call. Audit logs attribute every record change, comment, and status action to that user, not a shared service account.

Where is the Kintone API key stored?

In Scalekit's managed AES-256 token vault, namespaced per tenant. To rotate it, the user reconnects with a new API key. Revocation is a single dashboard action. Credentials never appear in prompts, logs, or LLM context.

Can I limit what the agent does in Kintone?

Yes. Filter by tool name in listScopedTools to expose only what you want, for example kintone_records_list and kintone_record_get without kintone_records_delete, which deletes up to 100 records and cannot be undone. Scalekit also enforces scope checks before every API call.

What happens when a user revokes Kintone access?

The connection is invalidated on the next tool call. Subsequent requests for that user fail closed with a clear error. Other users in the tenant remain unaffected. The event is logged for audit.

Can the agent move records through Kintone process management?

Yes. kintone_record_status_update runs a process management action on one record, kintone_records_statuses_update runs actions on up to 100 records in one call, and kintone_record_assignees_update replaces who is assigned to the current step.