Twilio call recording to Graniite

Wire a Twilio voice number so every recorded call lands in your knowledge base 30 seconds after the hangup.

Record a Twilio call. Within about 30 seconds, the transcript is searchable in your Graniite library and any AI client connected via MCP can quote it.

The whole pipeline is one HTTP Request node in n8n.

What you are building

[Twilio call ends, recording finalizes]
        |
        v
[Twilio "recording-status-callback" webhook fires]
        |
        v
[n8n Webhook node receives RecordingUrl + metadata]
        |
        v
[n8n HTTP Request: POST /api/v1/ingest with kind=url]
        |
        v
[Graniite fetches the recording, AssemblyAI transcribes, embeddings written]
        |
        v
[About 30 seconds later: searchable in Graniite and every MCP client]

Prerequisites

A Twilio account with at least one voice number, configured to record calls.
n8n (cloud or self-hosted). Most no-code trigger systems work identically. Zapier, Make, and Pipedream all have webhook and HTTP Request equivalents.
A Graniite token. Mint at /settings/integrations:
- Capabilities: read and write
- Access: pick a specific folder such as Calls if you want all recordings auto-filed there. The scope-size-1 rule means new items will land in that folder automatically.
- Auto-revoke after: 90 days
Save the lev_… token in n8n: Credentials → New → Header Auth, name Graniite, header name Authorization, header value Bearer lev_….

Step 1: n8n webhook node

In n8n, create a new workflow:

Add a Webhook node as the trigger.
HTTP Method: POST
Path: any unique slug (for example, twilio-calls-to-graniite).
Save and activate the workflow. n8n shows you the production webhook URL, something like:
```
https://your-n8n-host/webhook/twilio-calls-to-graniite
```
Copy it.

Step 2: configure Twilio's recording-status callback

In the Twilio console:

Go to Phone Numbers → Active numbers and click your number.
Scroll to Voice & Fax.
A call comes in: set to whatever you use today (TwiML bin, Studio flow, and so on). This is not what we are changing.
Recording status callback URL: paste the n8n webhook URL from Step 1.
Recording status callback events: check completed. We only care once the recording has finalized in Twilio's storage.
Save.

Twilio will now POST to your n8n webhook every time a recording finalizes for that number. The payload includes RecordingUrl, RecordingSid, CallSid, and RecordingDuration.

Step 3: n8n HTTP Request to /ingest

Right after the Webhook node, add an HTTP Request node:

Field	Value
Method	`POST`
URL	`https://graniite.co/api/v1/ingest`
Authentication	Generic Credential Type, Header Auth, your `Graniite` credential
Body Content Type	JSON
Specify Body	Using JSON

For the JSON body:

{
  "kind": "url",
  "url": "{{ $json.body.RecordingUrl }}",
  "in_kb": true,
  "auto_transform": false
}

{{ $json.body.RecordingUrl }} is n8n expression syntax. It pulls the URL out of the Twilio webhook payload that n8n passed to this node. The .body part is n8n's wrapper for webhook payloads. Remove it if you are testing the node with a Manual Trigger instead.

Save the workflow.

Step 4: test with a real call

Call your Twilio number from your phone.
Leave a short voicemail or have a brief conversation.
Hang up.
In the n8n Executions tab, within about 10 seconds you should see a green successful execution.

Inspect the HTTP Request output. You should see:

{
  "status": "transcribing",
  "content_id": "uuid",
  "user_item_id": "uuid",
  "folder_id": "uuid or null"
}

status: "transcribing" means AssemblyAI has accepted the URL and is processing. Wait about 30 seconds. Visit graniite.co/feed. The new item appears with the transcript ready to read.

(Optional) Step 5: wait for transcription before continuing

If your n8n flow needs to gate on transcription finishing (for example, to trigger a Slack notification with the transcript text), add a Wait and HTTP Request loop after the ingest node:

[HTTP: POST /api/v1/ingest]   returns { status: "transcribing", user_item_id }
        |
        v
[Wait 30 seconds]
        |
        v
[HTTP: GET /api/v1/items/{{ $json.user_item_id }}]
        |
        v
[IF: $json.transcription_status === "done"]
   |
   +--- yes: Continue
   |
   +--- no: Loop back to Wait

For short calls (under 3 minutes), you will usually be done after the first poll. Long calls can take 2 or 3 polls.

Trade-offs and gotchas

Twilio media URL auth

Twilio's RecordingUrl is signed and accessible without auth for a window after the call. If your n8n run is delayed, the URL may return 401. In practice the webhook fires within seconds and Graniite fetches immediately, so this rarely bites. If it does, the more robust path is to download the recording from Twilio first (using their API credentials in n8n), re-host the file somewhere with a stable URL (S3, Drive), and ingest that URL. Alternatively, use the binary upload flow.

Use a single "Calls" folder and accept the rare duplicate. This is cheap because the contents row dedupes (the URL is the same) and only the user_items row duplicates.
Or check Graniite for an existing item with the same source URL before ingesting (one extra GET /api/v1/items?folder_id=... call).

What this unlocks

Ask Claude, Cursor, or ChatGPT "What did Sarah say about the Q3 budget on yesterday's call?" MCP search hits the transcript.
Pipe call transcripts into the bulk import recipe's search index for full-text grep over them.
Combine with Drive sync so call notes and your written meeting notes live in the same library.

n8n quickstart: the underlying URL-ingest pattern this recipe rests on.
POST /api/v1/ingest: the endpoint reference.