Make

Push task data out of Atarim, or pull data in from thousands of other tools, without writing any code.

Atarim team Updated 30 Jul 2026 · 7 min read

Integrations

Before you start

Relevant for

Project Managers, Developers, and Marketing Teams who want Atarim task data to reach the other tools they work in.

Required knowledge

Familiarity with Atarim’s task management, and enough comfort in Make to build a basic scenario.

Tools & resources needed

An Atarim account on a plan that includes integration connectors.
A Make account.
Admin access in Atarim.

Make is an automation platform that connects Atarim to hundreds of other apps. Enable the integration, copy your API key, and build a scenario — from there, task data can reach Slack, Gmail, Trello or wherever else your team works, the moment something happens in Atarim.

Enabling Make reveals the API key you will paste into your Make connection.

Make is an automation platform that connects Atarim to hundreds of other apps. As the integration describes it in Atarim, you can fully automate processes to push data outside of Atarim, or pull data in from thousands of other tools. In practice that means task data reaching Slack, Gmail, Trello or whatever else your team lives in — automatically, the moment something happens in Atarim.

Enable Make and Copy Your API Key

Under Connected Apps, select Integrations. The panel lists the available integrations, each with its logo and controls.

Find Make and switch its toggle on. A confirmation reads Integration settings changed successfully!, and the integration’s details expand.

Find the API Key field that appears beneath the description and select the copy icon. The key is on your clipboard, ready for Make.

The Integrations panel in Atarim settings with the Make toggle — Find Make in Settings → Connected Apps → Integrations and switch its toggle on

The Make integration expanded in Atarim, showing the API Key field with its copy icon — The API Key field appears beneath the description — use the copy icon

Tip

The expanded Make row includes a link to create a new scenario in Make. Using it takes you straight to the right place, which saves navigating Make’s menus yourself.

Treat the key like a password

It authorises access to your Atarim account. Only paste it into trusted automation platforms, and keep it out of email and chat. If you think it has been exposed, contact support.

Make is a plan feature

Where your plan does not include integration connectors the toggle is locked and names the minimum plan required, and only the workspace owner can change the subscription. If Integrations is not in your sidebar at all, your role does not have access to it. Learn More About User Roles And Permissions

Connect Atarim to Make

In Make, start a new scenario — either from the link in Atarim or from your Make dashboard.

Select the + icon to add a module.

Search for and select Atarim.

Choose a trigger. Watch New Task is the usual starting point — it runs whenever a new task is created in Atarim.

When prompted to create a connection, paste the API Key you copied and give the connection a name. Make stores the connection so you can reuse it in later scenarios without pasting the key again.

Existing connections listed in Make — Connections in Make — stored once and reusable across scenarios

The scenario builder canvas in Make — The Make scenario builder

Creating a new scenario in Make — Starting a new scenario

Searching for the Atarim module in Make — Search for and select Atarim

Choosing the Watch New Task trigger in the Atarim module — Watch New Task — the usual starting trigger

Creating a new Atarim connection in Make — Create the connection and give it a name

Pasting the Atarim API key into the Make connection dialog — Paste the API key you copied from Atarim

Name the connection after the workspace

Rather than something generic like “Atarim”. If you later connect a second workspace, unnamed connections become impossible to tell apart in Make’s dropdowns.

Send Atarim Data to Another App

With the Atarim module in place, add a second module to decide what happens when the trigger fires.

Add another module to the scenario.

Choose a destination app — Gmail, Slack, Trello or anything else Make supports.

For an email example, select Gmail and then Send an Email.

Map the Atarim fields into the message. Use the task title as the subject and the task comment as the content.

Add any other fields you need.

Field available from Atarim	Useful for
Task Title	The subject line, or the headline of a Slack message.
Task Comment Message	The body — what the person actually asked for.
Page URL	Letting the recipient jump straight to the page in question.
Task Type	Routing different kinds of request to different destinations.
Automatic Screenshot	Giving the recipient visual context without opening Atarim.
Creator Email	Knowing who raised it, and replying to the right person.

Choosing a destination app for the second module in a Make scenario — Choose the destination app for the second module

Selecting Send an Email as the Gmail action in Make — For an email example, select Gmail then Send an Email

Mapping Atarim task fields into the destination module in Make — Map the Atarim fields into the message

Saving the module settings in a Make scenario — Save the module settings

Start simple

Map one or two fields, confirm the data arrives in the shape you expected, then add the rest. Debugging a six-field mapping that has never worked is far harder than growing one that has.

Test and Activate

Select Run Once to test the scenario.

Create a task in Atarim so the trigger has something to catch. The data flows through Make and you can inspect each module’s output.

If it worked, select Activate to turn the scenario on.

Running a Make scenario once to test it — Run Once, then create a task in Atarim to trigger it

Activating a scenario in Make so it runs automatically — Activate turns the scenario on — saving alone does not

Tip

Make’s scenario logs are the fastest way to diagnose a mismatch. If a message arrives empty or malformed, the log shows exactly which field came through blank, which is usually a mapping problem rather than a connection one.

Benefits

Benefit	In practice
Task data reaches your other tools	Requests land where your team already works instead of waiting to be noticed.
No code required	Scenarios are built visually, so this is not a developer task.
Hundreds of destinations	If Make supports the app, Atarim can feed it.
Context travels with the task	Page URL and the automatic screenshot mean the recipient sees what was meant.
Reusable connection	Paste the key once and use the connection across scenarios.

Example Use Cases

Situation	Scenario to build
A team that lives in Slack	Watch New Task, then post the title, page URL and screenshot to a channel.
A client who should get an acknowledgement	Watch New Task, then send an email confirming the request was received.
Work tracked in another project tool	Watch New Task, then create a matching item in Trello or similar.
Urgent requests needing attention fast	Use Task Type to route only certain requests to a high-visibility destination.
A weekly report of incoming work	Collect tasks into a sheet as they arrive rather than compiling by hand.

Known Limitations

It is a plan feature. Where integration connectors are not included the toggle is locked.

Admin access is needed to enable integrations and reach the API key.

One API key per account. It authorises the account rather than an individual project.

Regenerating the key breaks existing connections until the new one is pasted into Make.

Scenario behaviour is Make’s, not Atarim’s. Operation limits and scheduling follow your Make plan.

FAQs

What does the Atarim–Make integration do?

It lets you push data out of Atarim to other tools, and pull data in, using Make scenarios rather than custom code.

Which plans support it?

It requires a plan that includes integration connectors. If the toggle is locked in your Integrations panel, it names the minimum plan needed.

Do I need a separate Atarim account?

No. You use your existing account — the API key from your Integrations panel links it to Make.

Where do I find the API key again later?

In Settings → Connected Apps → Integrations, in the Make row beneath its description.

Which trigger should I start with?

Watch New Task is the usual starting point. It runs whenever a new task is created in Atarim.

Can I use one connection for several scenarios?

Yes. Make stores the connection once you have created it, so you do not paste the key again.

What happens if I turn the integration off?

Scenarios relying on that connection stop receiving data. Switch it back on and confirm the key in Make still matches.

Common issues

Integrations is not in your settings sidebar — your role does not have access. Ask an Administrator.
The Make toggle is locked — your plan does not include integration connectors. The lock names the minimum plan required.
Make rejects the API key — re-copy it with the copy icon rather than selecting the text, in case a space was included.
The trigger never fires — confirm the scenario is activated, not just saved, and create a task to test it.
Messages arrive with empty fields — a mapping problem. Check the scenario log to see which field came through blank.
The connection stopped working — the API key may have been regenerated. Paste the current key into the Make connection.
You cannot tell two connections apart in Make — rename them after their Atarim workspace.

Conclusion

Setup is short: enable Make in Atarim, copy the API key, create a connection in Make, and pick a trigger. From there the work is in Make rather than Atarim.

The habit that pays off is building one field at a time and testing with Run Once before activating — scenarios that grow from something working are far easier to keep working.

Tips & best practices

Apply filters in Make to trigger workflows only for specific tasks, preventing unnecessary automations.
Integrate Atarim with CRM tools like HubSpot or Salesforce to seamlessly send task updates.
Monitor API usage to avoid exceeding limits when using multiple webhooks.
Test workflows manually before automating to ensure data flows correctly.
Configure error handling in Make to receive alerts if an automation fails.

Was this article helpful?

The Stack: Mapping Your Preferred Plugin to Each Functional Category What It’s For, and Why It’s Worth Filling In Atarim’s workflows and AI agents constantly need to answer one question: which tool does this job Integrations · 13 min read Atarim MCP: Connecting Claude, Codex, and Other Coding Agents Step-by-Step Guide What This Actually Does Think of it as a direct line between Atarim and your developer’s AI assistant. Normally, if a client Integrations · 13 min read Atarim Figma Plugin: Overview & Why It Exists Select a frame, pick a destination, push. Feedback happens in Atarim afterwards. The Atarim Figma Plugin pushes design frames from Figma into Atarim, where Integrations · 9 min read