Resources · Make integration

Qontext Make integrationAutomate Qontext with Make.

Can Make fill your Qontext vault while you work in other tools? The Qontext Make integration gives you 5 action modules: three to ingest content, one to retrieve context, one to call the API. This guide shows how to connect your key and build a first scenario.

Try the Qontext integration on MakeSee the 5 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the Qontext Make integration do for you?

The Qontext Make integration links your Qontext vault to a Make scenario, the automation you build in Make as a chain of bricks called modules. Qontext has no trigger in Make, so your scenario starts from another app or from a schedule, then sends content into the vault or reads context back out of it.

A vault that follows your website. Point Ingest a website at a page your team keeps up to date, and the scenario hands it to Qontext without anyone copying and pasting.

Notes that land in one place. When a support agent closes a ticket or a sales rep writes a call summary in another app, Ingest an unstructured text pushes that free text to the vault. If the text needs labels such as a client name or a source, Ingest data with metadata is the module to pick.

Answers built on what the vault knows. Retrieve context pulls context from Qontext so the next module in your scenario can use it, for example in a reply draft.

What Make does not offer here: a trigger that fires when something changes in Qontext. For endpoints the four named modules skip, Make an API call reuses your connection. Keep in mind that the Make documentation for this app is AI-generated from the vendor docs and may contain mistakes. New to the editor? The Make training covers the basics, Make pricing explains how runs are counted, and n8n vs Make helps if you are still weighing both tools.

Connect

How do you connect Qontext to Make?

  1. 01

    Create an API key in Qontext

    Open your vault in Qontext, go to the Data Access section and click the button that creates a new API key. Copy the key shown on screen. You need an active Qontext account for this step.

  2. 02

    Add a Qontext module in Make

    In your scenario, add any Qontext module and click Create a connection. A connection is your Qontext account linked to Make once, then reused by every Qontext module you add later.

  3. 03

    Name it and paste the key

    The Connection name field is optional, but a clear name helps when you run several vaults. Paste the API key you copied and save: every Qontext module you add next reuses it.

First scenario

Your first scenario with Qontext

GoalWhen a new note is written in another app, Make sends its text to your Qontext vault.

  1. 01

    Create the scenario

    From the Scenarios page, create a new scenario and click the + to place the first module. Since Qontext has no trigger, this first module comes from the app where your notes live.

  2. 02

    Pick the source app

    Search for your note or ticket app, choose its module, and create its connection. Make then lists the folders or objects it can read, so you pick them instead of typing paths.

  3. 03

    Add Ingest an unstructured text

    Click the + on the right of the first module, search for Qontext and pick Ingest an unstructured text. Connect your vault with the API key, then map the note body from the previous module.

  4. 04

    Test with Run once

    Click Run once. Make runs the scenario one time and shows the bundles each module received; a bundle is one item passed along, here one note. Check that the text reached Qontext as expected.

  5. 05

    Schedule and switch it on

    Open the clock on the first module to set the schedule, every 15 minutes by default, then switch the scenario on. Each module run on a bundle counts as one operation on your plan.

Modules

What the Qontext modules do

Qontext gives you 5 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

Qontext1

Ingest a website

ActionIn the docs only

This module brings a website into your Qontext vault, so its content becomes part of what Qontext knows without manual copying. The module name is all the documentation gives about its behavior.

When to use it
your team publishes a help center or product page and you want the vault to hold the same material after each update your scenario detects.
Watch out
the doc lists no fields, so open the module and read what it asks for before mapping anything.
Qontext2

Ingest an unstructured text

ActionIn the docs only

Free text goes straight into the vault with this one: a call summary, a ticket reply, an email body. You get the words stored in Qontext without having to shape them first.

When to use it
the source app hands you plain text and you have no labels to attach to it.
Watch out
if you later need to know where a text came from, choose Ingest data with metadata instead, since this module is named for raw text only.
Qontext3

Ingest data with metadata

ActionIn the docs only

Pick this module when the content should arrive in Qontext together with descriptive details, such as the client it concerns or the tool it came from. The vault then receives more than bare text.

When to use it
a CRM record or a form entry where the context around the data matters as much as the data itself.
Watch out
the documentation does not say which metadata Qontext accepts, so run it once and check the bundle before relying on it.
Qontext4

Make an API call

ActionIn the docs only

With Make an API call you reach any endpoint of the Qontext API from your scenario, using the same connection as the other modules. It covers whatever the four named modules leave out.

When to use it
the Qontext API offers an action you need and none of the listed modules performs it.
Watch out
you write the request yourself, so test it with Run once and read the bundle it returns before switching the scenario on.
Qontext5

Retrieve context

ActionIn the docs only

Retrieve context works in the other direction: it reads from your Qontext vault and passes the result to the next module. That turns the vault into a source your scenario can draw on.

When to use it
a new request comes in through another app and the following step, a reply draft or a summary, should lean on what the vault already holds.
Watch out
the documentation describes no parameters, so look at what the module returns during a test run first.
Need help

Need help automating Qontext with Make?

A person reads every message.

FAQ

Qontext and Make: common questions

01Is the Qontext Make integration free?
Yes, on the Make side. Qontext is a standard app, so its modules are available from the Free plan. That plan allows 2 active scenarios, a minimum interval of 15 minutes between scheduled runs, 5 minutes of execution per run, files up to 5 MB and 512 MB of data transfer. Paid plans drop the interval to 1 minute and remove the cap on active scenarios. You still need an active Qontext account with an API key, and its subscription is set on the Qontext side, not by Make.
02What do you need to connect Qontext to Make?
An active Qontext account and an API key. To get the key, open your vault in Qontext, go to the Data Access section, click the button that creates a new key and copy it. In Make, add a Qontext module, click Create a connection, optionally give the connection a name, and paste the key. That single connection then serves every Qontext module in your scenarios, so you only do this once per vault.
03Can a Qontext scenario start in real time?
Not from Qontext itself, because the app has no trigger module in Make. Your scenario starts in one of two ways. Either it runs on a schedule set on its first module, every 15 minutes by default, or it opens on a trigger from another app, and if that trigger is instant, the other app calls Make through a webhook as soon as something happens. In both cases the Qontext modules then act on the data that trigger passed along.
04What if a Qontext module is missing in Make?
Use Make an API call. It reaches any endpoint of the Qontext API with the connection you already set up, so an action the four named modules skip is still within reach. You write the request yourself, which is why a test with Run once matters. Also remember that Make's documentation for Qontext is generated with AI from the vendor docs and may contain mistakes; when something looks off, confirm it with Qontext directly.
05Should you use Make or n8n with Qontext?
It depends on where the rest of your automations already live. On Make, Qontext comes with 5 action modules, including a generic API call, and it works from the Free plan. Many apps also have an n8n node, but whether Qontext has one is something to confirm in n8n before you decide. If your other scenarios already run in Make, keeping Qontext there means one editor and one set of connections to look after.
Same platform

Other docs you might need on this stack.

Browse all integrations