Resources · Make integration

Disciple Tools Make integrationAutomate Disciple Tools with Make.

Tired of typing the same records into Disciple Tools by hand? The Disciple Tools Make integration offers 2 action modules and no trigger. This guide shows how to link your account, then builds a first scenario that creates records for you.

Try the Disciple Tools integration on MakeSee the 2 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the Disciple Tools Make integration do for you?

The Disciple Tools Make integration lets a Make scenario, the automation you build in Make, write into your Disciple Tools site without code. It has two modules, the bricks of a scenario: one creates a record, the other calls the Disciple Tools API directly, the door other software uses to talk to it. Data comes from another app, and Disciple Tools receives it.

Records created from a form. A form tool sends each answer to Make, and Create Post Type Record turns it into a new record. Nobody retypes the entry, and nothing gets lost between the inbox and the database.

A spreadsheet imported row by row. Each row travels as one bundle, the item passed from a module to the next, so the same module creates one record per row. Run it once on a short sheet first, then on the real one.

Anything else through the API. Make An API Call reuses your connection to reach any endpoint of the Disciple Tools API, which covers what the single action module leaves out.

What Make does not do here: watch Disciple Tools for changes. The app has no trigger, so a scenario always starts in another app or on a schedule. Make also flags its own documentation for this app as AI-generated, so check important details with Disciple Tools. If you are weighing tools, the n8n vs Make comparison lays out the criteria, and the Make pricing page explains what each plan counts. To learn the editor properly, see the Make training.

Connect

How do you connect Disciple Tools to Make?

  1. 01

    Copy three values from Disciple Tools

    In Disciple Tools, click the gear icon at the top right, then Admin. Open Settings (DT) in the left column and the Site Link System tab. Copy the DT Base URL, the API key and the Post Type shown there.

  2. 02

    Add the module and open the connection

    In your Make scenario, add a Disciple Tools module and click Create a connection. A connection is your Disciple Tools account linked to Make once, then reused by both modules. The Connection name field is optional but helps later.

  3. 03

    Paste the values and save

    Paste the credentials you copied in the first step, or follow the instructions Make displays in the window. Once saved, the connection appears in the module and in any other Disciple Tools module you add afterward.

First scenario

Your first scenario with Disciple Tools

GoalWhen a new entry lands in another app, Make creates the matching record in Disciple Tools.

  1. 01

    Create the scenario

    On the Scenarios page, create a new scenario and click the + to add the first module. Since Disciple Tools has no trigger, this first module belongs to the app where your entries arrive.

  2. 02

    Set up the source app

    Search that app by name, pick its module, click Create a connection and fill the fields. Make lists what it can read once the connection exists, so there is no path to remember.

  3. 03

    Add Create Post Type Record

    Click the + on the right of the first module, search Disciple Tools and choose Create Post Type Record. Pick your connection, then map each piece of data from the previous module into the record.

  4. 04

    Test with Run once

    Click Run once. Make executes the scenario one time and shows the bundles each module received. Open Disciple Tools and check that the new record looks right before going further.

  5. 05

    Schedule and switch on

    Open the clock on the first module, Scheduling, to set how often Make checks the source app. A new scenario runs every 15 minutes by default. Then switch the scenario on.

Modules

What the Disciple Tools modules do

Disciple Tools gives you 2 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

Disciple Tools1

Create Post Type Record

ActionIn the docs only

This action adds a new record to Disciple Tools for every bundle it receives, so data collected elsewhere lands in your database without anyone copying it over.

When to use it
a sign-up form, a shared sheet or another tool gathers people you want to follow up in Disciple Tools.
Watch out
each bundle counts as one operation and creates one record, so run the scenario once on a single test entry before switching it on to avoid a pile of duplicates.
Disciple Tools2

Make An API Call

ActionIn the docs only

Here you get access to any endpoint of the Disciple Tools API, through the same connection as the other module, which covers what Create Post Type Record cannot do on its own.

When to use it
your scenario needs something beyond creating a record and no listed module offers it.
Watch out
you write the request yourself, so keep the Disciple Tools API reference open and test with Run once before going live.
Need help

Need help automating Disciple Tools with Make?

A person reads every message.

FAQ

Disciple Tools and Make: common questions

01Is the Disciple Tools Make integration free?
Yes, Disciple Tools is a standard app, so it works on the Make Free plan. That plan allows 2 active scenarios, a minimum of 15 minutes between two scheduled runs, 5 minutes of execution per run, files up to 5 MB and 512 MB of data transfer. Paid plans (Core, Pro, Teams and Enterprise) bring the interval down to 1 minute, remove the cap on active scenarios and allow 40 minutes of execution. Usage is counted in operations, one per module run on one bundle. Your Disciple Tools subscription is a separate matter handled by Disciple Tools.
02What do you need to connect Disciple Tools to Make?
You need an active Disciple Tools account with a valid username and password. From the gear icon, open Admin, then Settings (DT) and the Site Link System tab: that page shows the DT Base URL, the API key and the Post Type. Copy all three. In Make, add a Disciple Tools module, click Create a connection, optionally name it, and paste the values. The same connection then serves both modules of the app, so you only do this once per account.
03Does the Disciple Tools Make integration react in real time?
No, because Disciple Tools has no trigger module in Make, so Make cannot notice a change inside Disciple Tools by itself. A scenario starts elsewhere instead. Put a trigger from another app first, the form or tool where your data appears, and let Create Post Type Record follow it. If that first module is a scheduled trigger, Make polls on the scenario schedule, every 15 minutes by default and never under 15 minutes on the Free plan. If it is an instant trigger, the other app alerts Make through a webhook as soon as something happens.
04What if the Disciple Tools module you need is missing in Make?
Use Make An API Call. It reaches any endpoint of the Disciple Tools API with the connection you already set up, so reading or changing data that Create Post Type Record does not touch stays possible inside the same scenario. You will need the Disciple Tools API documentation to write the request. Keep one caveat in mind: Make marks its own documentation for this app as AI-generated and advises checking important details with Disciple Tools, so confirm the endpoint there before relying on it.
05Should you use Make or n8n for Disciple Tools?
It depends on your case, and the first step is a check: many apps also have an n8n node, so look whether Disciple Tools has one. On the Make side the facts are simple: 2 action modules, a connection built from the DT Base URL and API key, a Make An API Call module for everything else, and a Free plan to try it without commitment. The n8n vs Make comparison on the site sets the criteria side by side so you can decide for your own situation.
Same platform

Other docs you might need on this stack.

Browse all integrations