Semarize

Automations

Connect Semarize to your automation stack. Step-by-step flows for Zapier, Make, n8n, and Clay - using each platform's native blocks and terminology.

How automation works with Semarize

Every automation follows the same core pattern: a trigger fires when a new conversation is available, the transcript is sent to the Semarize API, and the structured output (scores, flags, evidence) is routed to downstream tools. All requests go through POST /v1/runs. Add "mode": "sync" for platforms that need an inline response, or use async mode with polling or workspace webhooks for completion events.

Which mode to use

All runs use a single endpoint: POST /v1/runs. Set the mode field to control execution behavior.

mode"sync"

Synchronous

Blocks until evaluation completes. Returns 200 with full run detail. If the run doesn't complete in time, returns 202 with sync_fallback: true. Best for Zapier, Make, and Clay.

Recommended for most automations
mode"async"default

Asynchronous

Returns 202 immediately with a run_id. Poll GET /v1/runs/:runId or configure workspace webhooks to receive terminal status events without a polling loop.

Polling or webhooks
Webhooks are workspace-level in v1 (one endpoint per workspace), delivered at-least-once with retries and HMAC signatures. Dedupe on Semarize-Delivery-Id (or Semarize-Event-Id). If a webhook payload is too large, Semarize sends a thin event and you can fetch full details via GET /v1/runs/:runId.
ZapierNo-code automation for everyone

Semarize + Zapier

Zapier organizes automations as Zaps - each Zap has a Trigger (what starts it) and one or more Action steps (what happens next). Zapier doesn't support native loops, so use POST /v1/runs with "mode": "sync" which returns results directly in the response.

Zap flow
Trigger
New Recording
Gong / Fireflies / Recall.ai
App: Gong
Event: New Call Recording
Output: transcript, call_id, participants
Action
Webhooks by Zapier
Custom Request - POST /v1/runs (sync)
Method: POST
URL: https://api.semarize.com/v1/runs
Headers: Authorization: Bearer smz_live_...
Body: { kit_code, mode: "sync", input: { transcript } }
Response returned inline
Action
Formatter by Zapier
Extract brick values from JSON response
Input: {{Step 2 output}}
Extract: bricks.overall_score.value
Extract: bricks.risk_flag.value
Extract: bricks.pain_point.value
Action
Salesforce - Update Record
Write extracted signals to Opportunity
Object: Opportunity
Record: {{Step 1 call_id}}
AI Score: {{Step 3 overall_score}}
Risk Flag: {{Step 3 risk_flag}}
Pain Point: {{Step 3 pain_point}}
Action
Slack - Send Channel Message
Notify team with evaluation summary
Channel: #deal-signals
Message: New eval for {{call_id}}
Score: {{overall_score}}, Risk: {{risk_flag}}

Setup steps

1

Create a new Zap. Choose your call recording app (Gong, Fireflies, Recall.ai) as the Trigger and select "New Call Recording" as the event.

2

Add an Action step: search for "Webhooks by Zapier" and choose "Custom Request". Set method to POST, URL to https://api.semarize.com/v1/runs, and add your Authorization header.

3

In the request body, map the transcript from Step 1 into the input.transcript field. Set kit_code to your Kit's code and mode to "sync".

4

Add a "Formatter by Zapier" Action to parse the JSON response. Extract each brick value you need (e.g. bricks.overall_score.value).

5

Add a Salesforce (or HubSpot, Sheets, etc.) Action to write the extracted brick values to your CRM record.

6

Optionally add a Slack Action to notify your team. Map the brick values into the message template.

7

Test each step, then turn on the Zap.

Zapier - Webhooks by Zapier body
// Webhooks by Zapier - Custom Request
// Method: POST
// URL: https://api.semarize.com/v1/runs
{
"kit_code": "YOUR_KIT_CODE",
"mode": "sync",
"input": {
"transcript": {{Step 1 Transcript}}
}
}
Full Zapier automation guide - use cases, templates, and advanced patterns
MakeVisual automation with branching logic

Semarize + Make

Make (formerly Integromat) organizes automations as Scenarios built from Modules. Each module performs one operation - HTTP requests, JSON parsing, routing, or app actions. Use POST /v1/runs with "mode": "sync" for simple flows, or the default async mode with a Repeater module for polling.

Scenario modules
Module 1
Webhook - Custom Webhook
Receives transcript payload from your system
Type: Custom webhook
Data structure: { transcript, call_id }
Module 2
HTTP - Make a Request
POST /v1/runs (sync) to Semarize
URL: https://api.semarize.com/v1/runs
Method: POST
Headers: Authorization: Bearer smz_live_...
Headers: Content-Type: application/json
Body type: Raw (JSON)
Body: { kit_code, mode: "sync", input: { transcript: {{1.transcript}} } }
Parse response: Yes
Module 3
JSON - Parse JSON
Parse the Semarize response body
JSON string: {{2.data}}
Data structure: Semarize run output
Router
Router - Branch on Signals
Route to different actions based on brick values
Branch 1: IF risk_flag.value = true
Branch 2: ALL (fallthrough)
Branch 1 - Risk detected
Module 4a
Slack - Create a Message
Alert team about high-risk deal
Channel: #deal-alerts
Text: Risk flagged for {{1.call_id}}
Score: {{3.bricks.overall_score.value}}
Branch 2 - All deals
Module 4b
Salesforce - Update a Record
Write all brick values to Opportunity
Module: Opportunities
Record ID: {{1.call_id}}
AI Score: {{3.bricks.overall_score.value}}
Pain Point: {{3.bricks.pain_point.value}}

Setup steps

1

Create a new Scenario. Add a Webhooks module (Custom webhook) as the trigger. Define the incoming data structure with transcript and call_id fields.

2

Add an HTTP module ("Make a request"). Set method to POST, URL to https://api.semarize.com/v1/runs. Add Authorization and Content-Type headers. Set body type to Raw and paste the JSON payload with mode set to "sync", mapping {{1.transcript}} from the webhook.

3

Add a JSON module ("Parse JSON") to parse the response from the HTTP module. Create a data structure matching the Semarize output format.

4

Add a Router module. Create Branch 1 with a filter: 3.bricks.risk_flag.value equals true. Leave Branch 2 as a fallthrough (no filter).

5

On Branch 1, add a Slack module ("Create a Message") to alert your team when risk is detected. Map brick values into the message.

6

On Branch 2, add a Salesforce module ("Update a Record") to write all brick values to the Opportunity. Map each field from the parsed JSON.

7

Set the scenario schedule (e.g., every 15 minutes or immediately via webhook). Activate the scenario.

Make - HTTP module body (Raw JSON)
// HTTP Module - Make a request
// URL: https://api.semarize.com/v1/runs
// Method: POST
{
"kit_code": "YOUR_KIT_CODE",
"mode": "sync",
"input": {
"transcript": {{1.transcript}}
}
}
// Router filter for risk branch:
// Condition: {{3.bricks.risk_flag.value}} = true
Full Make automation guide - scenarios, routers, and advanced patterns
n8nSelf-hosted, developer-friendly workflows

Semarize + n8n

n8n organizes automations as Workflows built from Nodes. Each node performs one operation - receiving webhooks, making HTTP requests, transforming data, or branching logic. n8n natively supports loops, making it ideal for the async /v1/runs endpoint with a polling pattern using Wait and IF nodes. Alternatively, use a workspace webhook as the trigger to avoid polling entirely.

Workflow nodes
Node 1
Webhook
Receive transcript payload
HTTP Method: POST
Path: /semarize-eval
Response: Immediately
Output: { transcript, call_id }
Node 2
HTTP Request - Create Run
POST /v1/runs (async)
Method: POST
URL: https://api.semarize.com/v1/runs
Authentication: Header Auth
Name: Authorization
Value: Bearer smz_live_...
Body: { kit_code, input: { transcript: {{$json.transcript}} } }
Loop until complete
Node 3
Wait
Pause before polling
Wait: 2 seconds
Resume: After time interval
Node 4
HTTP Request - Poll Run
GET /v1/runs/:runId
Method: GET
URL: https://api.semarize.com/v1/runs/{{$node['Node 2'].json.run_id}}
Authentication: Header Auth (same)
Node 5
IF - Check Status
Is the run complete?
Condition: {{$json.status}} ≠ 'succeeded'
True → back to Node 3 (Wait)
False → continue to Node 6
Run complete
Node 6
Code - Transform Output
Extract and reshape brick values
Language: JavaScript
Extract: items[0].json.output.bricks
Map to: { score, risk, pain_point }
Node 7
Postgres / HTTP Request
Write signals to your database or API
Operation: Insert / Update
Table: call_evaluations
Columns: call_id, score, risk_flag, pain_point

Setup steps

1

Add a Webhook node as the workflow trigger. Set HTTP Method to POST and define a path (e.g., /semarize-eval). Your system will POST transcripts to this URL.

2

Add an HTTP Request node. Set method to POST, URL to https://api.semarize.com/v1/runs. Under Authentication, select Header Auth and set name to Authorization, value to Bearer smz_live_your_key.

3

In the request body, set Body Content Type to JSON and map the transcript from the Webhook node using {{$json.transcript}}. Add your kit_code.

4

Add a Wait node. Set Resume to "After Time Interval" and set the interval to 2 seconds. This pauses before each poll.

5

Add another HTTP Request node to poll the run status. Set method to GET, URL to https://api.semarize.com/v1/runs/ and append the run_id from Node 2 using an expression.

6

Add an IF node. Set condition: {{$json.status}} is not equal to "succeeded". Connect the True output back to the Wait node (creating the loop). Connect the False output forward.

7

Add a Code node to extract and reshape the brick values from the completed run. Map each brick's value, confidence, reason, and evidence into your desired format.

8

Add a final node (Postgres, HTTP Request, Slack, etc.) to write the transformed signals to your database or notify your team.

n8n - Code node (JavaScript)
// n8n Code Node - Transform Semarize output
const bricks = items[0].json.output.bricks;
return [{
json: {
score: bricks.overall_score.value,
risk: bricks.risk_flag.value,
pain_point: bricks.pain_point.value,
evidence: bricks.pain_point.evidence,
}
}];
Full n8n automation guide - self-hosted workflows, polling loops, and advanced patterns
ClayData enrichment at scale

Semarize + Clay

Clay organizes enrichment as Tables with Columns. Each column can be a source column (your input data), an Enrichment column (runs an integration per row), or a Formula column (transforms data with expressions). The HTTP Enrichment column calls the Semarize API once per row and returns the response directly into the table.

Table columns (left → right)
Source Column
Import - CSV / CRM
Rows of transcripts from your data source
Column A: call_id (text)
Column B: transcript (long text)
Column C: rep_name (text)
Import: CSV upload or Salesforce sync
Enrichment Column
HTTP Enrichment - Semarize
POST /v1/runs (sync) for each row
URL: https://api.semarize.com/v1/runs
Method: POST
Headers: Authorization: Bearer smz_live_...
Body: { kit_code, mode: "sync", input: { transcript: /Transcript/ } }
Response path: (root - full JSON)
Response populates column
Formula Column
Extract Score
Pull overall_score from enrichment
Formula: {{HTTP Enrichment}}.bricks.overall_score.value
Output type: Number
Formula Column
Extract Risk Flag
Pull risk_flag boolean from enrichment
Formula: {{HTTP Enrichment}}.bricks.risk_flag.value
Output type: Boolean
Formula Column
Extract Pain Point
Pull extracted pain_point text
Formula: {{HTTP Enrichment}}.bricks.pain_point.value
Output type: Text
Action
Export to CRM
Push enriched table back to Salesforce / HubSpot
Destination: Salesforce Opportunities
Match on: call_id
Map: score → AI_Score__c
Map: risk → Risk_Flag__c
Map: pain_point → Pain_Point__c

Setup steps

1

Create a new Clay table. Import your data via CSV upload or connect directly to Salesforce/HubSpot. Ensure you have columns for call_id and transcript.

2

Add an Enrichment column. Choose "HTTP / API" as the enrichment type. Set URL to https://api.semarize.com/v1/runs and method to POST.

3

Under Headers, add Authorization: Bearer smz_live_your_key and Content-Type: application/json.

4

In the Body field, write the JSON payload. Reference the transcript column using Clay's /Column Name/ syntax: { "kit_code": "YOUR_KIT_CODE", "input": { "transcript": /Transcript/ } }

5

Run the enrichment. Clay sends one request per row and stores the full JSON response in the enrichment column.

6

Add Formula columns to extract individual brick values. Use dot notation on the enrichment column: {{HTTP Enrichment}}.bricks.overall_score.value for the score, .bricks.risk_flag.value for the flag, etc.

7

Add more formula columns for any additional brick values your Kit returns - confidence scores, reasons, evidence arrays, categorical labels.

8

Export the enriched table back to your CRM, or download as CSV for further analysis.

Clay - HTTP enrichment body (per row)
// Clay HTTP Enrichment Column
// Runs once per row in your table
{
"kit_code": "YOUR_KIT_CODE",
"mode": "sync",
"input": {
"transcript": /Transcript/ <- Clay column reference
}
}
// Formula columns to extract values:
// Score: {{HTTP Enrichment}}..bricks.overall_score.value
// Risk flag: {{HTTP Enrichment}}..bricks.risk_flag.value
// Pain point: {{HTTP Enrichment}}..bricks.pain_point.value
// Evidence: {{HTTP Enrichment}}..bricks.pain_point.evidence
Full Clay enrichment guide - tables, batch processing, and advanced patterns

What you get back

Regardless of which platform you use, the Semarize API returns the same structured JSON. Each brick in your Kit produces a typed value. Depending on configuration, bricks may also include confidence, reason, and evidence fields.

Example response - POST /v1/runs (sync mode, 200)
// Same shape as GET /v1/runs/:runId
{
"run_id": "run_8f3a...",
"status": "succeeded",
"duration_ms": 1200,
"output": {
"bricks": {
"overall_score": { "value": 72, "confidence": 0.94 },
"risk_flag": { "value": false, "confidence": 0.91 },
"pain_point": { "value": "Losing 3 hours/week on manual data entry", "evidence": ["...we're losing 3 hours a week just on..."] }
}
}
}

Map each output.bricks.*.value field to a CRM field, spreadsheet column, or Slack message in your automation.

Ready to automate?

Get your API key and connect Semarize to your automation platform in minutes.