Resources · Make integration

Drimify Make integrationAutomate Drimify with Make.

Can Make pick up what Drimify collects and pass it on for you? The Drimify Make integration gives you 2 modules: one trigger that watches for new data collections and one Make an API Call module. This guide connects your API key, then walks you through a first scenario you can test right away.

Try the Drimify integration on MakeSee the 2 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the Drimify Make integration do for you?

The Drimify Make integration links your Drimify account to Make, a no-code tool where you build a scenario (the automation itself, a chain of modules). A module is one brick of that chain. Drimify brings two of them: Watch New Data Collection to start a scenario, and Make an API Call to reach the rest of the Drimify API.

Hand new entries to the tools your team already uses. Watch New Data Collection starts the scenario, and each item it returns arrives as a bundle (one item passed from module to module). From there, a module of another app in Make can take over, such as a sheet, a CRM or a chat channel.

Reach what the listed modules skip. Make an API Call sends a request to any endpoint of the Drimify API with the same connection, so you are not stuck when no ready-made module exists for your task.

Test before you switch anything on. The Run once button runs the scenario a single time and shows you each bundle, which is the fastest way to see what Drimify actually sends.

Keep the limits in mind. Make's documentation for Drimify is AI-generated from the vendor's own docs and warns that it may contain mistakes, so check anything important with Drimify. Stuck on an error? The Make troubleshooting guide covers the common cases. Weighing tools first? Read the n8n vs Make comparison, and if you would rather learn the editor properly, the Make training starts from zero.

Connect

How do you connect Drimify to Make?

  1. 01

    Copy your API key in Drimify

    Open your Drimify account and go to the API keys management page. Copy the key shown on screen. Your account needs an active subscription that includes the API integration service, otherwise there is no key to copy.

  2. 02

    Open the connection window in Make

    In your scenario, add a Drimify module and click Create a connection. A connection is your Drimify account linked to Make once, then reused by both modules. Filling in Connection name is optional, but a clear name helps later.

  3. 03

    Paste the key and save

    Paste the API key you copied into the credentials field, or follow the instructions Make shows on screen, then confirm. The connection now appears in the module, and Make can start reading your Drimify account.

First scenario

Your first scenario with Drimify and Make

GoalWhen a new data collection shows up in Drimify, Make picks it up and sends a request to the Drimify API endpoint you choose.

  1. 01

    Create the scenario

    From the Scenarios page, create a new scenario and click the + in the middle of the editor to place the first module.

  2. 02

    Add Watch New Data Collection

    Search for Drimify, pick Watch New Data Collection and select the connection you just created. Make then shows the settings it can read from your account.

  3. 03

    Chain Make an API Call

    Click the + to the right of the trigger and add Make an API Call. Point it to the Drimify endpoint you need and map values from the trigger's bundle into the request.

  4. 04

    Test with Run once

    Click Run once. Make executes the scenario one time and lets you open each module to read the bundles it received, so you can check the data before going further.

  5. 05

    Schedule and switch it on

    Open the clock on the first module. A new scenario checks every 15 minutes by default, and you can change that. Then flip the scenario on so it runs without you.

Triggers

What starts a Drimify scenario

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

Drimify1Watch New Data Collection

Watch New Data Collection

triggerIn the docs only

This trigger gives your scenario a starting point: every new data collection it finds in Drimify becomes a bundle that the next modules can use, so nothing has to be copied by hand.

How it fires
scheduled, going by its name, since Make's documentation does not state the type. Make checks the app on the scenario's schedule, every 15 minutes by default.
When to use it
pick it when a new Drimify collection should kick off work in another tool.
Watch out
run it once and read the bundle before you pass any of its values to the next module, because the documentation gives no description of the data it returns.
Modules

What else the Drimify app can do in Make

Drimify gives you 1 module. For each one: what it does for you, when to reach for it, and what to watch out for.

Drimify1

Make an API Call

ActionIn the docs only

With this module you get access to any endpoint of the Drimify API from inside your scenario, using the connection you already set up, so you never have to handle the API key twice.

When to use it
reach for it whenever the task you have in mind goes beyond watching new data collections.
Watch out
Make lists no fields for it, so the endpoint and the request come from Drimify's own API documentation.
Need help

Need help automating Drimify with Make?

A person reads every message.

FAQ

Drimify and Make: common questions

01Is the Drimify Make integration free?
Yes on the Make side: Drimify is a standard app, available from the Free plan. That plan gives you 2 active scenarios, at least 15 minutes between two scheduled runs, up to 5 minutes per execution, files up to 5 MB and 512 MB of data transfer. Paid plans lower the interval to 1 minute and remove the cap on active scenarios. On the Drimify side, the documentation requires an account with a subscribed API integration service, so check Drimify's pricing page for that part.
02What do you need to connect Drimify to Make?
You need an active Drimify account with a subscription to the API integration service, plus the API key found on the API keys management page of that account. In Make, add a Drimify module, click Create a connection, give it a name if you want, and paste the key. That single connection then serves both Drimify modules, the trigger and Make an API Call, so the setup happens only once.
03Does the Drimify trigger in Make react in real time?
Probably not. Make's documentation does not give the type of Watch New Data Collection, and its name points to a scheduled trigger, meaning Make checks Drimify on the scenario's schedule rather than being called by Drimify. A new scenario runs every 15 minutes by default. On the Free plan the minimum interval is 15 minutes, and paid plans go down to 1 minute. If timing matters, test it with Run once and watch the clock badge on the module.
04What if the Drimify module you need is missing in Make?
Use Make an API Call. When an app has this module, the scenario can call any endpoint of that app's API with the same connection, so a task the trigger does not cover is still within reach. The endpoint and its parameters come from Drimify's API documentation, not from Make. Also keep in mind that Make's Drimify documentation is AI-generated and may contain mistakes, so confirm important details with Drimify directly.
05Should you use Make or n8n for Drimify?
It depends on the tool you already work in. The same app often has an n8n node too, so check whether one exists for Drimify before deciding. On Make, you get a trigger for new data collections and Make an API Call for everything else, both on one connection, and the app is available from the Free plan. The comparison between the two platforms is covered in a dedicated article on this site, linked higher on the page.
Same platform

Other docs you might need on this stack.

Browse all integrations