n8n recipe

This workflow takes a meeting’s file from the node before it, sends it to Lobbe, waits for it, and reads the finished meeting as one Markdown document, ready for a note, a message or an email. It has four HTTP Request nodes: one sends, one asks for the status in a loop with a Wait node and three IF nodes, one retries a failure that can recover, and one reads.

A workflow that only hands meetings over, and never reads them, needs less: see A submit-only flow.

Before you start

The token. Make one in Connections with Send meetings and Read (recordings:write and recordings:read). Read is what lets the last node fetch the meeting. The token spends minutes, so give it a daily cap. Like every token, it works only while Developer mode is on.

The credential. Keep the token in an n8n credential, never in a node:

In n8n, create a credential of the type Header Auth.
Set its Name to Authorization, and its Value to Bearer lobbe_…: the word Bearer, a space, then your token.
In each node that calls Lobbe, set Authentication to Generic Credential Type and Generic Auth Type to Header Auth, then pick this credential.

A node’s settings are saved with the workflow, and workflows get exported and shared. An exported workflow names its credentials, but doesn’t carry them.

1. Send the meeting

HTTP Request node
  Method: POST
  URL: https://app.lobbe.ai/api/v1/recordings
  Credential (Header Auth): Authorization = Bearer <your token>
  Body: Form-Data, field audio = the meeting's file

Then poll the statusUrl it answers with, about once a minute.

The Credential (Header Auth) line above is what the credential sends: don’t type it into the node. The node’s settings:

Setting	Value
`Method`	`POST`
`URL`	`https://app.lobbe.ai/api/v1/recordings`
`Authentication`	The `Header Auth` credential
`Send Body`	On, with `Body Content Type` set to `Form-Data`
A body parameter	`Parameter Type` `n8n Binary File`, `Name` `audio`, and as `Input Data Field Name` the item’s field that holds the file (`data`, unless an earlier node named it otherwise)
A second body parameter	`Parameter Type` `Form Data`, `Name` `naming`, `Value` `skip`

audio is the field Lobbe reads the file from. n8n sends the file with the type in its binary data’s mimeType. A 400 VALIDATION with the message Unsupported audio type means that type isn’t one Lobbe takes: see Upload limits.
naming=skip means the meeting never stops for its speakers’ names, so the loop below always ends. Without it, the owner’s Name speakers setting decides, and a meeting can wait at NAMING for hours: see Skipping naming at upload.
More fields, such as title and recordedAt (when the meeting happened), go in as more Form Data parameters: see POST /recordings.
Retries. If you turn on the node’s Retry On Fail, also send an Idempotency-Key header, with a value made once for each file before this node, so a retry can’t make a second meeting: see Idempotency and retries.

Name this node Send meeting: the loop below reads the meeting’s id from it. The answer is 202, with the id in recording.id.

2. Wait for it

Six nodes make a loop that asks for the status once a minute and retries a failure that can recover: a Wait node, two HTTP Request nodes and three IF nodes. A Stop and Error node ends the run on a failure that can’t.

A Wait node: Resume set to After Time Interval, for 1 minute.
An HTTP Request node for the status: Method GET, the same credential, and as URL this expression:
```
https://app.lobbe.ai/api/v1/recordings/{{ $('Send meeting').item.json.recording.id }}/status
```
It is the statusUrl the send answered with. The id comes from the Send meeting node every time round, whatever the node before this one answered. If you named that node otherwise, put its name in the expression.
An IF node with the condition {{ $json.status }} is equal to READY. Its true output goes on to step 3. Its false output goes to a second IF node.
A second IF node with the condition {{ $json.status }} is equal to FAILED. Its false output goes back to the Wait node, and its true output to a third IF node.
A third IF node with two conditions, both required (AND): {{ $json.error.retryable }} is true (Boolean), and {{ $runIndex }} is less than 3 (Number). $runIndex counts this node’s earlier runs, so a meeting is retried at most three times. Its true output goes to the retry node below. Its false output ends the run, through a Stop and Error node with {{ $json.error.code }} in its message.
An HTTP Request node for the retry: Method POST, the same credential, Never Error on (under Options, then Response), and as URL this expression:
```
https://app.lobbe.ai/api/v1/recordings/{{ $('Send meeting').item.json.recording.id }}/retry
```
Its output goes back to the Wait node.

Why retry instead of stopping: Lobbe retries a failed step by itself after a short wait, so the status can read FAILED for a moment and then move on. The retry is safe even then. It never starts a second run while Lobbe’s own is pending, it costs nothing more, and it answers 409 NOT_FAILED when the meeting has already recovered: Never Error keeps that answer from ending the run. Any other answer to the retry is left to the next status read: the meeting either moves on, or reads FAILED again and uses up one more retry. A meeting whose error.retryable is false (no speech in it, or a damaged file) would fail the same way again, so the loop stops at once. See FAILED and retry.

3. Read the Lobbe

At READY, the status carries bundleUrl, the address of the whole meeting. One more HTTP Request node reads it:

Setting	Value
`Method`	`GET`
`URL`	`{{ $json.bundleUrl }}?format=markdown`
`Authentication`	The same credential
`Response Format` (under `Options`, then `Response`)	`Text`

The answer is one Markdown document: the title, the meeting’s details, the Lobbe’s sections and the transcript. n8n puts it in the item’s data field, for the next node to use. Without ?format=markdown, the same meeting comes as JSON: see GET /recordings/{id}/bundle.

bundleUrl is null for a token without Read, so this node needs recordings:read.

When a request fails

Apart from the retry node, leave each HTTP Request node to stop the workflow on an error, as n8n does by default. Then an error answer, a 403 DEVELOPER_MODE_OFF or a 402 INSUFFICIENT_MINUTES for example, ends the run instead of going round the loop. To hear about it, pick an Error Workflow in the workflow’s settings. What each code means is in Errors.

Read finished meetings instead

A token with Read alone can’t send meetings, but one node lists the finished ones:

HTTP Request node
  Method: GET
  URL: https://app.lobbe.ai/api/v1/recordings/ready
  Credential (Header Auth): Authorization = Bearer <your token>

Each item's bundleUrl returns the whole meeting.

The answer’s items are your finished meetings, newest first. For the next page, send nextCursor back as cursor. To fetch one meeting as Markdown, add ?format=markdown to its bundleUrl, as in step 3. To pick up each new meeting once it is ready, see Pull meetings into your own tools.