{"site":{"name":"Koji","description":"AI-native customer research platform that helps teams conduct, analyze, and synthesize customer interviews at scale.","url":"https://www.koji.so","contentTypes":["blog","documentation"],"lastUpdated":"2026-11-22T00:08:05.500Z"},"content":[{"type":"documentation","id":"3401bda2-5abd-4d84-b05d-c6115ea7e070","slug":"make-research-automation","title":"Connect Koji to Make (Make.com): Build No-Code Customer Research Automations","url":"https://www.koji.so/docs/make-research-automation","summary":"Koji connects to Make (formerly Integromat) without a dedicated app. To invite people, a scenario sends the study's interview link from any Make email or messaging module, or adds them to Koji's Participants so Koji emails the invitation and a reminder from the study's Self-recruit tab (paid plans: Insights 20 emails a month, Interviews 50, Enterprise 1,000). To run interviews inside your own product, an HTTP > Make a request module POSTs to Koji's Start Interview endpoint with the API key as a Bearer token; the study comes from the key, and every body field is optional: a respondent object (external_id, display_name, metadata), mode (text or voice) and locale. Koji returns an interview_id, a session_token and the opening question. A Make custom webhook URL added as a Koji webhook (Integrate, then Webhooks, on the Insights, Interviews and Enterprise plans) receives a signed interview.completed event when each interview is finished and scored, and an HTTP module can fetch the analysis (summary, sentiment, themes, quality score, structured answers, transcript) from the read endpoint to route onward. Make routers and filters branch on typed structured-question answers. Each interview uses 1 credit for text or 3 for voice. The headless API and API keys are included on the Interviews and Enterprise plans.","content":"# Connect Koji to Make (Make.com): Build No-Code Customer Research Automations\n\n**Answer first:** Make (formerly Integromat) is a visual automation canvas, and Koji plugs into it without a dedicated app. There are two ways to put a Koji interview into a Make scenario. To **invite people**, a scenario sends your study's interview link from your own email or messaging module, or you add the people to Koji's Participants and let Koji email them from the study's Self-recruit tab. To **run interviews inside your own product**, an **HTTP module** calls Koji's headless API to start an interview session. To **collect results** from any study, add a Make **Custom webhook** URL as a Koji webhook: Koji sends a signed `interview.completed` event the moment each interview is finished and scored, and an HTTP module can fetch the full analysis from Koji's read endpoint to route it to Slack, Notion, a CRM or a spreadsheet. It is the same pattern as Koji's [Zapier](/docs/zapier-research-automation) and [n8n](/docs/n8n-research-automation) integrations, with Make's routers and filters for more complex branching. Most scenarios take 20 to 40 minutes to build.\n\n## Why use Make with Koji\n\nMake sits between hundreds of apps and lets you wire logic visually (triggers, routers, filters, iterators) without writing a service. For customer research, that means you can put a Koji AI interview at the exact moment a meaningful event happens anywhere in your stack, and then send the resulting insight to the place your team already looks. You get the depth of a moderated interview (Koji's AI asks adaptive follow-ups in voice or text and analyzes every conversation automatically) with the reach of an automation platform that already talks to your billing, CRM, forms and messaging tools.\n\nCompared to hand-built middleware, Make gives you retries, error handling and a visual audit trail for free. Compared to a raw survey tool, Koji turns each triggered touch into a real conversation rather than a form nobody finishes.\n\n## The building blocks\n\n### 1a. Invite people to an interview\n\nThe simplest scenario never calls the API. Every Koji study has a shareable interview link. When your trigger fires, a Make module (Gmail, Outlook, SendGrid, Slack, Intercom) sends that link with a short, personal note. Interview links work on every plan.\n\nIf you would rather Koji send the email, add the people to **Participants** (import a CSV or add them one by one), group them into an audience, and on the study's **Self-recruit** tab email the audience an invitation or a reminder. Each person gets their own interview link, and you can see who received the email, opened it and started the interview. Koji's recruitment email is included on paid plans: Insights includes 20 emails a month, Interviews 50 and Enterprise 1,000, and extra emails are €10 per 1,000 plus VAT. A useful split is to let Make decide *who* should be interviewed and *when* (for example, by tagging contacts in your CRM), and use Koji's built-in email for the invitation and the reminder.\n\n### 1b. HTTP module: start a headless interview (Make to Koji)\n\nUse the headless API when the conversation happens inside your own product or interface rather than on Koji's interview page. Add an **HTTP > Make a request** module pointed at Koji's [Start Interview endpoint](/docs/starting-interviews-via-api):\n\n- Method `POST` to `https://www.koji.so/api/v1/interviews/start`, with your Koji API key as a Bearer token in the Authorization header (see [API authentication](/docs/api-authentication)). The study comes from the API key, so you never send a study ID.\n- Every body field is optional. Pass a `respondent` object with an `external_id` (your customer or user ID, mapped from the trigger), an optional `display_name` and free-form `metadata`, plus `mode` (`text` by default, or `voice`) and `locale`.\n- Koji replies with an `interview_id`, a `session_token` and usually the AI's opening question in `initial_message`. Your product then carries the conversation forward through the message and complete endpoints. In voice mode the reply also includes voice credentials.\n\nYour `external_id` comes back in the webhook event for this interview, so the second building block can match the result to the right person without you storing the `interview_id` first.\n\n### 2. Custom webhook: receive each finished interview (Koji to Make)\n\nKoji tells Make when an interview is done. Start a second scenario with a **Webhooks > Custom webhook** module and copy its URL. In Koji, open the study, go to **Integrate**, then **Webhooks**, click **Add webhook**, paste the URL and keep the event `interview.completed`. Choose \"Only this study\" or \"All studies, including new ones\". Then click **Send test event** so Make learns the data structure. Only workspace owners and admins can add webhooks, and they come with the Insights, Interviews and Enterprise plans.\n\nFrom then on, Koji POSTs a signed event to Make as soon as each interview is finished and scored, whether it ran on Koji's interview page, in the embed or through the headless API. The event carries the interview and study IDs, the mode, the participant's `external_id` when you passed one, and trust signals: a 1 to 5 quality score, a quality level, whether the interview meets Koji's quality bar and a fraud-risk level. Test events arrive with the type `webhook.test`, so add a filter that only passes `type` = `interview.completed`.\n\nThe event doesn't carry the transcript or the analysis. For those, add an **HTTP > Make a request** module that GETs the event's `data.links.api` (Koji's read endpoint, `https://www.koji.so/api/v1/interviews/{interview_id}`) with your API key. The response holds the interview `status`, the `respondent` (including your `external_id`), `stats` such as message count and duration, the full `transcript`, and an `analysis` object with the summary, key insights, overall sentiment, theme tags, a quality score from 1 to 5 with a short rationale, and the typed structured answers. A nightly scheduled poll of the same endpoint still makes a good safety net for anything a scenario missed.\n\n## Three scenario recipes\n\n**Recipe A: Churn interview after a cancellation.**\n`Stripe (Watch events: subscription cancelled)` -> `Filter (plan, tenure)` -> `Gmail or your email tool (send the churn study link)`. Or route the same trigger to tag the customer in your CRM, then invite the tagged list from Koji's Self-recruit tab so Koji sends the invitation and a reminder and tracks who opened it. Read the churn themes in the study report as interviews come in. Pair with [cancel-flow exit interviews](/docs/cancel-flow-exit-interview), which embed the interview in the cancel flow itself.\n\n**Recipe B: In-product interview after onboarding, results to your CRM.**\n`HubSpot/Salesforce (contact reaches \"onboarded\" stage)` -> your product shows the embedded interview, started with `HTTP (start Koji interview)` and `external_id` set to the CRM contact ID -> `Data store (save interview_id)`. A second scenario starts from Koji's `interview.completed` webhook, fetches the analysis, and a `Router` writes sentiment and theme tags back to the CRM contact and alerts the CSM. See [CRM research integration](/docs/crm-research-integration-guide).\n\n**Recipe C: Scheduled batch from a spreadsheet.**\n`Schedule (every Monday)` -> `Google Sheets (watch new rows)` -> `Email module (send each person the interview link)`. For a list you contact often, import it into Koji's Participants once and send each week's invitation from the Self-recruit tab instead. See [Google Sheets + Koji](/docs/google-sheets-research-integration).\n\n## Use routers and filters for real logic\n\nMake's **routers** let one analyzed Koji interview fan out to several destinations, and **filters** let you act only on the interviews that matter. Common patterns:\n\n- Filter `analysis.sentiment = negative` AND quality score of 4 or more -> alert the account owner immediately.\n- Route by a `single_choice` root-cause answer to different Slack channels or Jira projects.\n- Iterate over `multiple_choice` or `ranking` answers to write one row per selected option.\n\nThis is where structured questions pay off. Each Koji study can mix question types such as `open_ended`, `scale`, `single_choice`, `multiple_choice`, `ranking`, `yes_no` and `price_ladder` (a price test), and because each returns a typed value, your Make filters and routers can branch on them reliably. Design them with the [structured questions guide](/docs/structured-questions-guide).\n\n## Reliability and security notes\n\n- Store your Koji API key in a Make **connection or keychain**, not in plain module fields.\n- Delivery is at least once, so keep each handled `interview_id` in a Make data store and skip any you have seen before.\n- Koji signs every delivery, but Make's custom webhook doesn't check the signature. Treat the webhook URL as a secret, and filter on `type` so `webhook.test` events never reach your CRM.\n- If Make doesn't answer, Koji retries six more times over about 35 hours, and failed deliveries can be resent from the webhook's log for 30 days.\n- Turn on Make's error handlers so a transient failure retries instead of dropping an interview.\n- For sensitive studies, run Koji in **anonymous mode** and route only the summary and theme tags downstream, never raw transcripts.\n\n## Plans and limits\n\nInterview links and Make's own email modules work on every Koji plan. Koji's built-in recruitment email is included on Insights (20 emails a month), Interviews (50) and Enterprise (1,000), with extra emails at €10 per 1,000 plus VAT. The headless API, and the API keys it needs, are included on the **Interviews and Enterprise plans**; on other plans the start endpoint returns a 403. Each interview uses credits like any other: 1 credit for a text interview and 3 for a voice interview. Webhooks, which push each finished interview to Make, are included on Insights, Interviews and Enterprise. On Insights the event itself (IDs, mode, your `external_id`, quality score) is enough for alerts and logging. Fetching the full analysis through the read endpoint needs an API key.\n\n## A closer look at the interview payload\n\nThe read endpoint returns one JSON object per interview. Parse it once with Make's JSON module and every field becomes mappable: `respondent.external_id` to match the person in your own systems, `analysis.sentiment` and the theme tags for the headline, the summary for a Slack message, the structured answers for typed values, the quality score (1 to 5) to filter out low-effort responses, and the `transcript` if you need the full conversation. From there Make's mapping panel wires each field into whatever downstream module you choose.\n\n## When to choose Make vs Zapier vs n8n\n\nAll three run the same Koji pattern (an invite or an HTTP call to start interviews, a Koji webhook to collect results), so pick by fit:\n\n- **Zapier** is the fastest to a first working zap and has the widest app catalog; ideal for simple one-trigger, one-action flows. See [Connect Koji to Zapier](/docs/zapier-research-automation).\n- **Make** shines when a single interview needs to fan out with routers, filters and iterators, or when you want a visual audit trail and cheaper high-volume operations.\n- **n8n** is the choice when you need self-hosting or want the pipeline in your own infrastructure. See [Connect Koji to n8n](/docs/n8n-research-automation).\n\n## Common pitfalls (and how to avoid them)\n\n- **Double processing.** Delivery is at least once. Record each `interview_id` in a data store and skip repeats.\n- **Test events in production.** Send test event posts a `webhook.test` message. Filter on `type` = `interview.completed` so tests never reach Slack or your CRM.\n- **No error handling.** Wrap the HTTP module with a Make error handler and retries so a transient failure does not silently drop an interview.\n- **Over-broad triggers.** Filter to the events that deserve an interview; do not invite someone on every record change.\n- **Key in plain text.** Keep the Koji API key in a Make connection, not a bare module field.\n\n## Put the interview at the moment that matters\n\nThe reason to run Koji through Make is timing. A survey sent days later gets stale, guarded answers; an AI interview that reaches a customer right after they cancel, upgrade or finish onboarding catches them while the experience is vivid. Make is the switchboard that makes that timing automatic across your stack, and Koji is the AI moderator that turns the moment into a real, analyzed conversation instead of a form nobody finishes.\n\n## Build Recipe B step by step\n\nTo make the API pattern concrete, here is the in-product interview with results routed to Slack and Notion.\n\nFirst scenario (start the interview): when your product is ready to show the interview, it calls a Make **Webhooks > Custom webhook** with the user's ID. An **HTTP > Make a request** module POSTs to Koji's Start Interview endpoint with `{\"respondent\": {\"external_id\": \"<user id>\"}, \"mode\": \"text\"}`, a **Webhook response** module hands the `interview_id`, `session_token` and `initial_message` back to your product to render the conversation, and a **Data store > Add a record** module saves the `interview_id` as pending.\n\nSecond scenario (handle the result): start with a **Webhooks > Custom webhook** module, copy its URL and add it in Koji under the study's **Integrate**, then **Webhooks**. Click **Send test event** so Make learns the data structure. Add a filter that passes only `type` = `interview.completed`, then an **HTTP > Make a request** module that GETs the event's `data.links.api` with your API key, then a **Router** with two routes. Route one has a **Slack > Create a Message** module posting the sentiment and theme tags to `#retention`, with a filter for negative sentiment so only the interviews worth a human's attention ping the channel. Route two has a **Notion > Create a Database Item** module logging the respondent ID, summary, theme tags and quality score. Finish with **Data store > Add a record** for the `interview_id`, and check that store right after the trigger, so a repeated delivery is skipped. That is a complete listening loop built from a handful of modules and no code, and it keeps running whether you are watching or not.\n\n## Related Resources\n\n- [Connect Koji to Zapier](/docs/zapier-research-automation)\n- [Connect Koji to n8n](/docs/n8n-research-automation)\n- [Research Automation with Webhooks](/docs/research-automation-webhooks)\n- [Structured Questions in AI Interviews](/docs/structured-questions-guide)\n- [Starting Interviews via API](/docs/starting-interviews-via-api)\n- [Google Sheets + Koji](/docs/google-sheets-research-integration)\n","category":"API Reference","lastModified":"2026-11-16T05:16:10.944503+00:00","metaTitle":"Koji + Make (Make.com): No-Code Research Automation","metaDescription":"Build Make.com scenarios that trigger Koji AI interviews from any app and route themes, sentiment, and transcripts to Slack, Notion, your CRM, or a spreadsheet, using HTTP modules and Koji webhooks.","keywords":["koji make integration","make.com research automation","integromat customer research","no code ai interviews","make webhook koji","trigger interviews from make","automate user research make"],"aiSummary":"Koji connects to Make (formerly Integromat) without a dedicated app. To invite people, a scenario sends the study's interview link from any Make email or messaging module, or adds them to Koji's Participants so Koji emails the invitation and a reminder from the study's Self-recruit tab (paid plans: Insights 20 emails a month, Interviews 50, Enterprise 1,000). To run interviews inside your own product, an HTTP > Make a request module POSTs to Koji's Start Interview endpoint with the API key as a Bearer token; the study comes from the key, and every body field is optional: a respondent object (external_id, display_name, metadata), mode (text or voice) and locale. Koji returns an interview_id, a session_token and the opening question. A Make custom webhook URL added as a Koji webhook (Integrate, then Webhooks, on the Insights, Interviews and Enterprise plans) receives a signed interview.completed event when each interview is finished and scored, and an HTTP module can fetch the analysis (summary, sentiment, themes, quality score, structured answers, transcript) from the read endpoint to route onward. Make routers and filters branch on typed structured-question answers. Each interview uses 1 credit for text or 3 for voice. The headless API and API keys are included on the Interviews and Enterprise plans.","aiPrerequisites":["A Koji account (API access is included on every plan, including free)","A Make (Make.com) account","Basic familiarity with Make modules, routers, and webhooks"],"aiLearningOutcomes":["Start Koji interviews from any Make trigger with the HTTP module","Poll Koji for analyzed interviews with a scheduled HTTP module","Route insights to Slack, Notion, a CRM, or a spreadsheet","Branch scenarios on structured-question values with routers and filters"],"aiDifficulty":"intermediate","aiEstimatedTime":"11 min read"}],"pagination":{"total":1,"returned":1,"offset":0}}