Connect Koji to Make (Make.com): Build No-Code Customer Research Automations
Use Make (formerly Integromat) scenarios to trigger Koji AI interviews from any app and route themes, sentiment, and transcripts to Slack, Notion, your CRM, or a spreadsheet, no code, using HTTP modules and Koji webhooks.
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 and n8n integrations, with Make's routers and filters for more complex branching. Most scenarios take 20 to 40 minutes to build.
Why use Make with Koji
Make 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.
Compared 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.
The building blocks
1a. Invite people to an interview
The 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.
If 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.
1b. HTTP module: start a headless interview (Make to Koji)
Use 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:
- Method
POSTtohttps://www.koji.so/api/v1/interviews/start, with your Koji API key as a Bearer token in the Authorization header (see API authentication). The study comes from the API key, so you never send a study ID. - Every body field is optional. Pass a
respondentobject with anexternal_id(your customer or user ID, mapped from the trigger), an optionaldisplay_nameand free-formmetadata, plusmode(textby default, orvoice) andlocale. - Koji replies with an
interview_id, asession_tokenand usually the AI's opening question ininitial_message. Your product then carries the conversation forward through the message and complete endpoints. In voice mode the reply also includes voice credentials.
Your 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.
2. Custom webhook: receive each finished interview (Koji to Make)
Koji 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.
From 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.
The 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.
Three scenario recipes
Recipe A: Churn interview after a cancellation.
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, which embed the interview in the cancel flow itself.
Recipe B: In-product interview after onboarding, results to your CRM.
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.
Recipe C: Scheduled batch from a spreadsheet.
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.
Use routers and filters for real logic
Make'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:
- Filter
analysis.sentiment = negativeAND quality score of 4 or more -> alert the account owner immediately. - Route by a
single_choiceroot-cause answer to different Slack channels or Jira projects. - Iterate over
multiple_choiceorrankinganswers to write one row per selected option.
This 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.
Reliability and security notes
- Store your Koji API key in a Make connection or keychain, not in plain module fields.
- Delivery is at least once, so keep each handled
interview_idin a Make data store and skip any you have seen before. - Koji signs every delivery, but Make's custom webhook doesn't check the signature. Treat the webhook URL as a secret, and filter on
typesowebhook.testevents never reach your CRM. - 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.
- Turn on Make's error handlers so a transient failure retries instead of dropping an interview.
- For sensitive studies, run Koji in anonymous mode and route only the summary and theme tags downstream, never raw transcripts.
Plans and limits
Interview 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.
A closer look at the interview payload
The 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.
When to choose Make vs Zapier vs n8n
All 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:
- 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.
- 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.
- n8n is the choice when you need self-hosting or want the pipeline in your own infrastructure. See Connect Koji to n8n.
Common pitfalls (and how to avoid them)
- Double processing. Delivery is at least once. Record each
interview_idin a data store and skip repeats. - Test events in production. Send test event posts a
webhook.testmessage. Filter ontype=interview.completedso tests never reach Slack or your CRM. - No error handling. Wrap the HTTP module with a Make error handler and retries so a transient failure does not silently drop an interview.
- Over-broad triggers. Filter to the events that deserve an interview; do not invite someone on every record change.
- Key in plain text. Keep the Koji API key in a Make connection, not a bare module field.
Put the interview at the moment that matters
The 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.
Build Recipe B step by step
To make the API pattern concrete, here is the in-product interview with results routed to Slack and Notion.
First 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.
Second 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.
Related Resources
Related Articles
API Authentication
How Koji Headless API authentication works: pk_live_ API keys, permissions, session tokens, and origin allowlists.
Cancel-Flow Exit Interviews: AI Moderation That Saves Churning Users
Replace your single-textarea cancellation survey with an AI-moderated exit interview that probes the real reason people leave and triggers save offers in real time.
How to Use Your CRM Data for Targeted AI Research: Import Participants and Personalize Every Interview
Your CRM already contains your best research sample. Learn how to export customer segments, import them into Koji, and invite each person with a personal link, either by Koji email with reminders and tracking or from your own CRM.
Google Sheets + Koji: Launch AI Interviews from a Spreadsheet and Auto-Log Every Insight Back
Turn a Google Sheet of contacts into a batch of Koji AI interviews, and auto-append every completed interview's themes, sentiment, quality score, and transcript link back to a live results tab — no data stack required.
Headless API Overview
Manage interviews programmatically with the Koji REST API — start, message, and complete interviews from your own code.
Sync Koji Customer Interviews to HubSpot: Live Insights on Every Contact
Push Koji interview transcripts, themes, and quality scores onto HubSpot contact and company records using the Koji API and the HubSpot API.
Connect Koji to n8n: Build Self-Hosted Customer Research Pipelines
Wire Koji into n8n with signed webhooks to build self-hosted pipelines that route every completed interview into Notion, Linear, Slack, your CRM, or any other system, without sending data through a third-party automation cloud.
Sync Koji Research Insights to Notion: Build a Self-Updating Research Repository
Connect Koji to Notion via Zapier (or the API) so every completed AI interview becomes a fresh Notion page — with transcript, structured answers, themes, quality score, and AI summary attached. Build a research repository that updates itself.
Real-Time Research Insights: How to See Themes, Quotes, and Quality Scores as Interviews Complete
Stop waiting weeks for analysis — modern AI research platforms surface themes, structured-question distributions, sentiment, and quality-scored quotes the moment each interview ends. Here is how real-time research insights work in Koji and how to design studies that take advantage of them.
Research Automation: How to Build Real-Time Research Pipelines with Webhooks
Build automated research pipelines on Koji: event-triggered interviews, a signed webhook when each one is finished and scored, and insight routing to Slack, your CRM or a warehouse.
Sync Koji AI Interviews to Salesforce: Customer Insights on Every Account, Contact, and Opportunity
Push Koji interview quotes, themes, sentiment and quality scores into Salesforce with a webhook-driven worker, or send personal interview links from a Salesforce report with no code.
Send Research Insights to Slack: Real-Time Customer Interview Notifications via Webhooks
Get customer interview insights from Koji into Slack. There is no native Slack app, but Koji sends a signed interview.completed webhook from any study (Integrate, then Webhooks), which a small receiver or Zapier, Make or n8n turns into a Slack message seconds after each interview. Step-by-step setup with message recipes.
Starting Interviews via API
Create interview sessions programmatically with POST /interviews/start: request fields, the 201 response, CRM linking, and voice mode.
Structured Questions in AI Interviews
Mix quantitative data collection — scales, ratings, multiple choice, ranking — with AI-powered conversational follow-up in a single interview.
Understanding Themes & Patterns
Learn how Koji identifies recurring themes across interviews and how to use them for decision-making.
User Research API: Embed AI Interviews into Any Product or Workflow
How to use Koji's User Research API to run AI-moderated interviews from your own backend. Covers REST endpoints, the embed widget, signed completion webhooks, authentication, rate limits, and headless interview patterns.
Webhook Setup
Set up Koji webhooks: get a signed interview.completed message on your server each time a participant finishes, with your own participant ID and a quality score.
Connect Koji to Zapier: Automate Customer Research Workflows in Minutes
Route every completed AI customer interview from Koji into 6,000+ Zapier apps — including Notion, Linear, Salesforce, Airtable, and Gmail. A step-by-step integration guide.