Resources · Make integration

Kintone (Legacy) Make integrationAutomate Kintone (Legacy) with Make.

Can your Kintone apps update themselves while your team works elsewhere? The Kintone (Legacy) Make integration gives you 12 modules: 1 scheduled trigger, 9 actions and 2 searches. This page shows how to link your account, build a first scenario and pick the right module for each job.

Try the Kintone (Legacy) integration on MakeSee the 12 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the Kintone (Legacy) Make integration automate?

The Kintone (Legacy) Make integration lets Make read and write the records, comments and files of your Kintone account without code. You build a scenario, the automation you run in Make, by chaining modules: each module is one brick, such as a trigger that starts the flow, a search or an action.

Records that fill themselves. A form, a shop or a spreadsheet sends its data to Make, and Create a Record writes a clean entry in the right Kintone app. Nobody retypes anything, and Update a Record keeps that entry current when the source changes.

A team that hears about changes. Watch Records picks up records on the scenario's schedule, and Create a Comment leaves a note on each one so the owner sees what happened, right inside Kintone.

Paperwork in the right place. A contract or a photo coming from another app goes to Kintone through Upload a File, and Update a Record Status moves the record forward once the document is in.

Know the limits before you start. The only trigger is scheduled, so Make checks Kintone at intervals rather than being called by it, and the Make documentation lists these modules without describing them: test each one with a single run before you rely on it. When a listed module falls short, Make an API Call reaches any other endpoint with the same connection. If you are also weighing n8n, read n8n vs Make, and to learn the editor step by step, look at Make training. Plan limits are covered in Make pricing.

Connect

How do you connect Kintone (Legacy) to Make?

  1. 01

    Open the connection window

    Add any Kintone module to your scenario and click Create a connection. A connection is your Kintone account linked to Make once; every Kintone module in your scenarios then reuses it.

  2. 02

    Describe your Kintone site

    In Connection Type, keep Kintone. Give the link a clear Connection name if you like, type your personal subdomain in Subdomain, then pick your URL's domain in the Domain Name section.

  3. 03

    Sign in and save

    Enter the login you use for Kintone in Username and Password, then click Save. If Kintone asks you to authenticate and confirm access, accept, and the connection is ready for every module.

First scenario

Your first scenario with Kintone (Legacy)

GoalWhen Watch Records picks up a record in Kintone, Make adds a comment to it so the record owner sees, right in Kintone, that the automation has picked it up.

  1. 01

    Create the scenario

    On the Scenarios page, create a new scenario and click the big + to place the first module on the canvas.

  2. 02

    Place the trigger

    Search for Kintone (Legacy), choose Watch Records and click Create a connection (or pick the one you already made). Then fill in the fields; once connected, Make lists what it can read.

  3. 03

    Add the comment

    Click the + to the right of the trigger and pick Create a Comment. Map the record coming from Watch Records into it, so each bundle, meaning each record passed along, gets its own comment.

  4. 04

    Test with Run once

    Click Run once. Make runs the scenario one time; open the bubble above each module to read the bundles it received and check the comment in Kintone.

  5. 05

    Schedule and switch on

    Open the clock on the first module. A new scenario checks every 15 minutes by default, the minimum on the Free plan. Keep it or change it, then switch the scenario on.

Triggers

What starts a Kintone (Legacy) scenario

1 module starts a scenario when something happens in Kintone (Legacy). A scheduled trigger is checked by Make on the scenario's schedule; an instant one is called by Kintone (Legacy) as soon as it happens.

Kintone (Legacy)1Watch Records

Watch Records

triggerIn the docs only

Watch Records is the door into every automation on this page: it hands your scenario the Kintone records it finds, one bundle per record, so the following modules can act on each of them.

How it fires
scheduled, Make checks the app on the scenario's schedule, every 15 minutes by default and down to 1 minute on paid plans. Kintone does not call Make.
When to use it
any time a Kintone entry should set off work elsewhere, like a message, a copy in another tool or a comment.
Watch out
the Make documentation gives no description of this trigger, so check with Run once which records it returns before you switch the scenario on.
Modules

Every Kintone (Legacy) module, explained

Kintone (Legacy) gives you 11 modules in 4 groups. For each one: what it does for you, when to reach for it, and what to watch out for.

Records

6 modules
Kintone (Legacy)1

Search Records

SearchIn the docs only

Search Records finds the Kintone entries you need and hands them over as separate bundles, so later modules can work on each one in turn.

When to use it
before updating a customer entry, to find it first instead of guessing which record to touch.
Watch out
a search can return zero, one or many records, and every following module runs once per result, which costs one operation each time.
Kintone (Legacy)2

Get a Record

ActionIn the docs only

Get a Record brings back one precise Kintone entry, so the rest of your scenario can read its values and reuse them anywhere.

When to use it
when an earlier module already gave you the record you want, and you only need its content, not a search across the app.
Watch out
it targets a single record, so reach for Search Records when you cannot point at one entry.
Kintone (Legacy)3

Create a Record

ActionIn the docs only

Create a Record writes a brand new entry in a Kintone app from data arriving in Make, which spares your team the copy and paste.

When to use it
a web form, an order or a signed quote should become a Kintone record the moment it reaches your scenario.
Watch out
without a check first, a rerun creates the same entry twice; place Search Records ahead of it if duplicates matter.
Kintone (Legacy)4

Update a Record

ActionIn the docs only

Update a Record changes the values of an existing Kintone entry, so the app reflects what just happened in another tool.

When to use it
a payment clears or a delivery ships, and the matching Kintone record should show it without anyone editing by hand.
Watch out
the module needs to know which record to change, so feed it the record from Watch Records, Search Records or Get a Record.
Kintone (Legacy)5

Update a Record Status

ActionIn the docs only

Update a Record Status moves a Kintone entry to another status, keeping status changes apart from ordinary value edits.

When to use it
an approval lands or a file arrives, and the record should advance to its next stage automatically.
Watch out
the documentation does not explain this module, so try it on a test record with Run once before letting it act on live entries.
Kintone (Legacy)6

Delete a Record

ActionIn the docs only

Delete a Record removes a Kintone entry for good, which keeps apps tidy when a request is cancelled or a test entry needs to go.

When to use it
a cancellation elsewhere means the matching Kintone record should disappear.
Watch out
treat every deletion as final. Before switching the scenario on, run it once on a test record and check which entry reaches this module.

Comments

3 modules
Kintone (Legacy)7

Search Comments

SearchIn the docs only

Search Comments collects the comments left on Kintone records, giving your scenario the discussion around an entry and not only its values.

When to use it
to copy the exchanges on a record into a report, a message or another app your managers read.
Watch out
like any search, it may return nothing or a long list, and each returned comment triggers the next modules separately.
Kintone (Legacy)8

Create a Comment

ActionIn the docs only

Create a Comment posts a note on a Kintone record, so the people who own it see an update in the place they already work.

When to use it
a record was handled by your scenario, a reply came in by email or a task was closed in another tool, and the team should know.
Watch out
each bundle creates one comment, so a trigger that returns many records will write many notes.
Kintone (Legacy)9

Delete a Comment

ActionIn the docs only

Delete a Comment removes a comment from a Kintone record, which helps clear notes your automation posted once they no longer matter.

When to use it
after a test run, or when a status note written by the scenario has become outdated.
Watch out
it cannot bring anything back, so pair it with Search Comments to target exactly the comment you mean to remove.

Files

1 module
Kintone (Legacy)10

Upload a File

ActionIn the docs only

Upload a File sends a document from another module into your Kintone account, so attachments stop living in inboxes and shared drives.

When to use it
a signed contract, an invoice PDF or a site photo arrives in Make and belongs with your Kintone data.
Watch out
on the Free plan Make handles files up to 5 MB, so larger documents need a paid plan.

Other

1 module
Kintone (Legacy)11

Make an API Call

ActionIn the docs only

Make an API Call reaches any endpoint of the Kintone API through the connection you already set up, covering what the eleven other modules leave out.

When to use it
you need a Kintone operation that no listed module offers, and the Kintone API documentation shows the endpoint for it.
Watch out
you write the request yourself here, so read the endpoint's page in the Kintone API documentation before you run it.
Need help

Need help automating Kintone (Legacy) with Make?

A person reads every message.

FAQ

Kintone (Legacy) and Make: common questions

01Is the Kintone (Legacy) Make integration free?
Yes, Kintone (Legacy) is a standard app in Make, so it works from the Free plan. That plan allows 2 active scenarios, runs scheduled scenarios at most every 15 minutes, stops each run after 5 minutes, handles files up to 5 MB and includes 512 MB of data transfer. Paid plans (Core, Pro, Teams and Enterprise) lower the interval to 1 minute, lift the cap on active scenarios and count usage in credits per month. Your Kintone subscription is a separate matter that Make does not cover.
02What do you need to connect Kintone (Legacy) to Make?
A Kintone account and its login details are enough, as the documentation lists no other prerequisite. When you click Create a connection, Make asks for the connection type, your Kintone subdomain, your username and password, and the domain of your Kintone address. Enter only the subdomain part of the URL, then save. If Kintone prompts you to authenticate and confirm access, accept it. The same connection is then reused by every Kintone module you add.
03Does the Kintone (Legacy) Watch Records trigger fire instantly?
No. Watch Records is a scheduled trigger: Make checks Kintone on the scenario's schedule, and Kintone never calls Make on its own. A new scenario checks every 15 minutes by default, which is also the shortest interval on the Free plan; paid plans go down to 1 minute. Each check that finds records passes them one by one to the next modules. If you need a scenario that starts right away, it has to begin with another app's instant trigger instead.
04What if a Kintone (Legacy) module you need is missing in Make?
Use Make an API Call. It sends a request to any endpoint of the Kintone API with the connection you already have, so you are not limited to the other listed modules. Check the Kintone API documentation for the endpoint, its method and what it expects. The Make documentation gives no numeric limit for these modules, so a quick Run once on test data is the safest way to see how each call behaves before you switch the scenario on.
05Should you use Make or n8n for Kintone (Legacy)?
It depends on the tool your team already knows. On the Make side, Kintone (Legacy) comes with 12 modules covering records, comments and files, one scheduled trigger and a Make an API Call module for the rest, all built visually in the scenario editor. Many apps also have an n8n node, so check whether one exists for Kintone before choosing. Neither tool is declared better here: compare the modules you need and the editor you find clearer.
Same platform

Other docs you might need on this stack.

Browse all integrations