Make + Tevyr

#What you can do

#Pattern 1 — Tevyr → Make (Tevyr webhook is the trigger)

This is the most common direction. Tevyr fires a webhook on every meaningful event; Make catches it and runs your scenario.

#Setup

1. In Make, click Create a new scenario
2. Click the empty first module and search for Webhooks
3. Pick Webhooks → Custom Webhook
4. Click Add to create a new webhook. Name it (e.g. "Tevyr session events"). Make generates a URL like https://hook.eu2.make.com/<random>. Copy it.

1. In Tevyr, open Settings → Webhooks for your event
2. Click Add Webhook, paste the Make URL, choose which events to send (e.g. session.started, session.completed, question.submitted)
3. Save. Click Test in Tevyr's webhook panel — Make should receive a test payload
4. Back in Make, click Determine data structure on the Webhook module — this teaches Make the JSON shape Tevyr sends. You must click this with a real test payload waiting, otherwise downstream modules can't see the fields.
5. Add the next module — any of Make's 2,000+ apps. Slack, Google Sheets, Teams, Notion, anything.

#Recipe — Q&A submitted → Slack message

1. Trigger: Tevyr webhook with event question.submitted
2. Add module: Slack → Create a Message
3. Channel: #qa-moderation
4. Message text — use Make's variable picker to drop in {{1.question.text}} and {{1.question.submitter_name}} (the 1. prefix is Make's module index)
5. Save and activate the scenario with the top-bar toggle

Every Q&A submission now lands as a Slack ping with the question text and the submitter's name when available.

#Recipe — session.completed → Google Sheets row

1. Trigger: Tevyr webhook with event session.completed
2. Add module: Google Sheets → Add a Row
3. Pick your spreadsheet and sheet
4. Map columns:
   • Date: {{1.session.completed_at}}
   • Session title: {{1.session.title}}
   • Speaker: {{1.session.speaker_name}}
   • Planned (sec): {{1.session.duration_seconds}}
   • Actual (sec): {{1.session.actual_duration_seconds}}
   • Overrun (sec): {{1.session.overrun_seconds}}

Run an event end-to-end — the spreadsheet has a complete log without anyone touching it.

#Recipe — timer.warning → email speaker

1. Trigger: Tevyr webhook with event timer.warning
2. Add a Filter between modules: only continue if 1.session.speaker_email is not empty
3. Add module: Email → Send an Email (or use Gmail / Outlook 365)
4. Subject: 5 minutes left — please start wrapping up
5. Body: Hi {{1.session.speaker_name}}, the timer just hit your warning threshold. About {{1.remaining_seconds}} seconds remaining.

Useful for remote speakers on Zoom who can't see a confidence monitor.

#Pattern 2 — Make → Tevyr (Make scenario calls Tevyr's API)

The reverse direction. Make triggers off something else (Calendly, Notion, HubSpot, anything in its catalog) and uses Tevyr's API to take action.

#Setup

1. In Make, Create a new scenario
2. Set the trigger module to whatever app you're listening to (e.g. Calendly → Watch Invitees Created)
3. Add the next module: HTTP → Make a request
4. URL: the Tevyr API endpoint (recipes below)
5. Method: GET
6. Map the trigger app's fields into Tevyr's URL parameters

#Recipe — Calendly booking → create Tevyr session

1. Trigger: Calendly → Watch Invitees Created
2. Action: HTTP → Make a request
3. URL: https://api.tevyr.com/v1/session/create
4. Query parameters:
   • room_id: your Tevyr room ID
   • api_key: your Tevyr API key
   • title: {{1.event_type.name}}
   • speaker_name: {{1.invitee.name}}
   • duration_seconds: {{1.event.duration}}
   • scheduled_start_time: {{1.event.start_time}}

Every Calendly booking auto-creates a Tevyr session. Open the controller — your day's lineup is already loaded.

#Recipe — Notion database update → message in Tevyr

1. Trigger: Notion → Watch Database Items
2. Action: HTTP → Make a request
3. URL: https://api.tevyr.com/v1/message/create?room_id=YOUR_ROOM_ID&api_key=YOUR_API_KEY&content={{1.title}}&type=staff

When someone updates the run-of-show Notion doc, Tevyr's staff screen gets a message with the new info.

#Pattern 3 — Tevyr macro fires a scenario (native template path)

Use this when you want a Tevyr macro step to fire a scenario inline — branch on the timer, the session, or prior step output before firing. Faster than the webhook fan-out path and the macro builder gives you per-fire field interpolation against {{ctx.*}}.

#Setup

1. In Make, Create a new scenario → Webhooks → Custom Webhook. Copy the URL.
2. In Tevyr, Settings → Integrations → Add new → Make, paste the URL, name the connection (e.g. "Make — broadcast scenario"), click Save

#Verify the wiring

1. Click Test on the new Tevyr connection — Tevyr POSTs a test payload to your Make webhook URL
2. Switch back to Make, click Run once on the scenario, then Determine data structure — Make displays the request and learns the JSON shape
3. Finish wiring your scenario's downstream modules and activate the scenario with the top-right toggle

#Use the connection in a macro

1. Drag flow.http_request into any macro
2. Pick your Make connection from the dropdown
3. Pick the Fire scenario action
4. Fill the fields:

#Payload shape Make receives

Every fire ships this body:

{
  "event": "session_started",
  "message": "Round 1 just started at 4:24 PM",
  "extra": { "speaker": "Round 1", "remaining": 1741 },
  "ctx": {
    "session_name": "Round 1",
    "event_name": "Boxing Rounds",
    "timer_remaining": 1741,
    "now_iso": "2026-05-16T04:24:18.442Z"
  }
}

Your scenario branches on event for routing (Router module + filters), reads message for human-readable copy, and pulls structured values from extra and ctx for downstream actions.

#Common payload reference

When Tevyr fires a webhook, the payload includes structured fields you can map in Make. Below are the most-used field paths for each event type:

See the Webhooks reference for the full payload shape of every event type.

#Troubleshooting

#"Make receives the request but downstream modules show no fields"

• Click Determine data structure on the Webhook module with a real test payload waiting. Until you do, Make stores the body as opaque JSON and downstream modules can't auto-complete on 1.session.title, etc.
• Tevyr's webhook Test button always fires the same fixture payload — use that to seed the data structure, then real fires will match.

#"Hitting Make's operations limit"

• Free Make accounts include 1,000 operations/month and each scenario module counts as one operation. A scenario with 5 modules consumed 5 ops every fire — high-traffic events blow through this fast.
• Filter aggressively at the front of the scenario: drop the run early on irrelevant events so downstream modules don't count.
• Use Aggregator modules to batch multiple Tevyr events into one downstream call (e.g. one Sheets append per minute instead of per session).

#"Tevyr fires the webhook but the scenario doesn't run"

• The scenario must be active — toggle it on with the top-bar switch. Inactive scenarios receive the request but silently no-op.
• Check Make's History tab for the scenario; failed runs land here with the response code.
• Tevyr retries failed deliveries up to 3 times with exponential backoff. Check Tevyr's webhook log for what Make returned.

#"Wrong region URL — Make 404s on incoming"

• Your Make webhook URL embeds the data-center region: eu2, eu1, us1, etc. If your account migrated regions, old webhook URLs return 404 — regenerate the webhook in Make and re-paste the new URL into Tevyr.

#Context variables

When Tevyr → Make via a macro step (using the Make template or Generic HTTP), the body fields support {{ctx.*}} interpolation. Make receives whatever fields you stitched in. See the full context-variable reference. Common ones: {{ctx.event.title}}, {{ctx.session.title}}, {{ctx.session.speaker_name}}, {{ctx.timer.remaining_seconds}}, {{ctx.now.iso}}.

#Triggered by webhook events

For the inverse — fire a scenario on every Tevyr event — use a webhook in Integration mode with your Make connection, OR use URL mode and paste the Make webhook URL directly. Both work; integration mode is friendlier when you have multiple scenarios to manage.

#Related

• Zapier — alternative catch-hook pattern with a larger app catalog
• n8n — alternative catch-hook pattern, self-hostable
• Macros — fire a Make scenario from a specific macro step (mid-show, conditional, etc.)
• API reference — every endpoint Make can call
• Webhooks — every event Tevyr can fire
• Integrations Overview — other tools you can wire alongside Make