> ## Documentation Index
> Fetch the complete documentation index at: https://docs.nekt.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Plaud as a data source

> Bring your Plaud Team recordings, transcripts, AI summaries and members to Nekt.

Plaud makes AI voice recorders and an app that transcribes and summarizes conversations. This connector reads your **Plaud Team** workspace through the Plaud Enterprise API and brings every recording the API can access (title, author, recording date and duration), the full transcript of each recording with speaker labels and timestamps, the AI summaries Plaud generated for it, and the members of your workspace.

> [!NOTE]
>
> The connector only reads data. It never creates, changes or deletes anything in Plaud.

## Configuring Plaud as a Source

In the [Sources](https://app.nekt.ai/sources) tab, click on the "Add source" button located on the top right of your screen. Then, select the Plaud option from the list of connectors.

Click **Next** and you'll be prompted to add your access.

### 1. Add account access

The connector uses the **Plaud Enterprise API**, which belongs to the Plaud Team workspace. Only a Plaud Team **admin** can set it up, and Plaud must enable it for your workspace.

> [!WARNING]
>
> The Plaud Enterprise API was released as a Private Beta, enabled by Plaud workspace by workspace. If your workspace does not have it yet, ask Plaud for Enterprise API access before creating the source.

Plaud does not use a password or secret for this API. Instead, you create a key pair: you keep the private key, and Plaud keeps the public key.

**1. Create a key pair**

On a computer with `openssl`, run:

```bash theme={null}
openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -out private_key.pem
openssl pkey -in private_key.pem -pubout -out public_key.pem
```

`public_key.pem` is the file you send to Plaud. Keep `private_key.pem` safe: it is what Nekt uses to sign in.

**2. Register the public key with Plaud**

Request Enterprise API access from Plaud and register `public_key.pem`. Plaud returns your **Client ID** and **API host** (and, for some regions, a token issuer and a key ID). See [Plaud's getting started guide](https://docs.plaud.ai/enterprise-api/getting-started).

**3. Let your members consent**

The next time your members open the Plaud app, they are asked whether they allow the workspace admin to read their recordings through the API. Team files are available right away; a member's private recordings only appear after that member consents.

The following configurations are available:

* **Client ID**: The Client ID Plaud issued for your workspace.
* **Private Key**: The full content of `private_key.pem`, including the `-----BEGIN PRIVATE KEY-----` and `-----END PRIVATE KEY-----` lines. The key must not be password-protected.
* **API Host**: The API host Plaud gave you. US workspaces use `https://api.plaud.ai`; Japan workspaces receive their own host.
* **Token Issuer** (optional, advanced): Only if Plaud gave you a token issuer different from the API host. Leave it empty otherwise.
* **Key ID** (optional, advanced): Only if Plaud gave you a key ID for your public key. Leave it empty otherwise.
* **Start Date** (optional, advanced): Only recordings created on or after this date are extracted. Leave it empty to extract the full history.

Once you're done, click **Next**.

### 2. Select streams

Choose which data streams you want to sync. For faster extractions, select only the streams that are relevant to your analysis. You can select entire groups of streams or pick specific ones.

> Tip: The stream can be found more easily by typing its name.

Select the streams and click **Next**.

### 3. Configure data streams

Customize how you want your data to appear in your catalog. Select the desired layer where the data will be placed, a folder to organize it inside the layer, a name for each table (which will effectively contain the fetched data) and the type of sync.

* **Layer**: choose between the existing layers on your catalog. This is where you will find your new extracted tables as the extraction runs successfully.
* **Folder**: a folder can be created inside the selected layer to group all tables being created from this new data source.
* **Table name**: we suggest a name, but feel free to customize it. You have the option to add a **prefix** to all tables at once and make this process faster!
* **Sync Type**: you can choose between INCREMENTAL and FULL\_TABLE.
  * Incremental: every time the extraction happens, we'll get only the new data, which is good if, for example, you want to keep every record ever fetched.
  * Full table: every time the extraction happens, we'll get the current state of the data, which is good if, for example, you don't want to have deleted data in your catalog.

Once you are done configuring, click **Next**.

### 4. Configure data source

Describe your data source for easy identification within your organization, not exceeding 140 characters.

To define your [Trigger](https://docs.nekt.com/runs/scheduling-and-triggers.md), consider how often you want data to be extracted from this source. This decision usually depends on how frequently you need the new table data updated (every day, once a week, or only at specific times).

Optionally, you can define some additional settings:

* Configure Delta Log Retention and determine for how long we should store old states of this table as it gets updated. Read more about this resource [here](https://docs.nekt.com/get-started/core-concepts/resource-control).
* Determine when to execute an **Additional [Full Sync](https://docs.nekt.com/get-started/core-concepts/types-of-sync#additional-full-sync)**. This will complement the incremental data extractions, ensuring that your data is completely synchronized with your source every once in a while. A full sync of Plaud reads every transcript and summary again, so keep it infrequent on large workspaces. A monthly full sync is still recommended: it picks up summaries Plaud adds to a recording without marking the recording as changed (see Data Quality Considerations).

Once you are ready, click **Next** to finalize the setup.

### 5. Check your new source

You can view your new source on the [Sources](https://app.nekt.ai/sources) page. If needed, manually trigger the source extraction by clicking on the arrow button. Once executed, your data will appear in your Catalog.

> [!WARNING]
>
> For you to be able to see it on your [Catalog](https://app.nekt.ai/catalog), you need at least one successful source run.

# Streams and Fields

## Available streams

The table below lists every stream, its **slug** (the exact identifier to pass when creating the source via API) and a short description.

| Stream | Slug | Sync | Description |
| - | - | - | - |
| Files | `files` | Incremental | Recordings of the workspace: Team files and the private files of members who consented. |
| File Transcripts | `file_transcripts` | Incremental | The transcript of each recording, as plain text and with speaker labels and timestamps. |
| File Summaries | `file_summaries` | Incremental | The AI summaries Plaud generated for each recording, one row per summary. |
| File Deletions | `file_deletions` | Incremental | Recordings Plaud reported as deleted. Select it together with Files. |
| Members | `members` | Full table | Members of the workspace, including removed members. |
| Workspaces | `workspaces` | Full table | The Plaud Team workspace of the credential. |

> [!NOTE]
>
> Audio files are not extracted. Plaud only provides a download link for the audio that expires within minutes, so it would not be usable once stored in a table.

## Joining transcripts and summaries to recordings

File Transcripts and File Summaries are read again every time their recording changes. `file_version` on those rows is the `version` of the recording when they were read, so to get only the summaries of the current version of each recording, join on both columns:

```sql theme={null}
SELECT
  f.id,
  f.title,
  f.recorded_at,
  t.transcript_text,
  s.content AS summary
FROM files AS f
LEFT JOIN file_transcripts AS t
  ON t.file_id = f.id
LEFT JOIN file_summaries AS s
  ON s.file_id = f.id
 AND s.file_version = f.version
```

## Fields by stream

> [accordion] Files
>
> Every recording the credential can access. Incremental: each sync reads only the recordings created or changed since the previous sync.
>
> Table: `files` · Primary key: `id` · Sync: Incremental (`updated_at`)
>
> | Field | Type | Description |
> | :- | :- | :- |
> | `id` | String | Plaud ID of the recording. |
> | `workspace_id` | String | ID of the workspace the recording belongs to. |
> | `title` | String | Title of the recording. |
> | `status` | String | Processing status of the recording, such as `ready`. |
> | `created_by_member_id` | String | ID of the member who created the recording (see Members). |
> | `recorded_at` | Datetime | When the audio was recorded (UTC). |
> | `created_at` | Datetime | When the recording was created in Plaud (UTC). |
> | `updated_at` | Datetime | When the recording was last changed (UTC). |
> | `version` | Integer | Version of the recording; it grows every time the recording changes. |
> | `duration_ms` | Integer | Length of the recording, in milliseconds. |
> | `has_transcript` | Boolean | Whether the recording has a transcript. |
> | `has_summary` | Boolean | Whether the recording has at least one AI summary. |
> | `is_deleted` | Boolean | `true` when Plaud reported the recording as deleted. |

> [accordion] File Transcripts
>
> The transcript of each recording that has one, read together with its recording.
>
> Table: `file_transcripts` · Primary key: `file_id` · Sync: Incremental (`file_updated_at`)
>
> | Field | Type | Description |
> | :- | :- | :- |
> | `file_id` | String | ID of the recording (joins with `files.id`). |
> | `language` | String | Language of the transcript, such as `en`. |
> | `utterance_count` | Integer | Number of utterances (speaker turns) in the transcript. |
> | `transcript_text` | String | The whole transcript as text, one utterance per line, starting with the speaker label when Plaud has one. |
> | `utterances` | String | Every utterance with `speaker_id`, `speaker_label`, `start_ms`, `end_ms` and `text` (JSON). |
> | `file_updated_at` | Datetime | `updated_at` of the recording when the transcript was read. |
> | `file_version` | Integer | `version` of the recording when the transcript was read. |

> [accordion] File Summaries
>
> The AI summaries of each recording that has any, one row per summary, read together with their recording.
>
> Table: `file_summaries` · Primary key: `id` · Sync: Incremental (`file_updated_at`)
>
> | Field | Type | Description |
> | :- | :- | :- |
> | `id` | String | Plaud ID of the summary. |
> | `file_id` | String | ID of the recording (joins with `files.id`). |
> | `template_id` | String | ID of the summary template used, when there is one. |
> | `format` | String | Format of the content, such as `markdown`. |
> | `content` | String | The summary text, in the given format. |
> | `created_at` | Datetime | When the summary was generated (UTC). |
> | `file_updated_at` | Datetime | `updated_at` of the recording when the summary was read. |
> | `file_version` | Integer | `version` of the recording when the summary was read. |

> [accordion] File Deletions
>
> Recordings that Plaud reported as deleted, read together with Files (select both). This stream only works as Incremental: set to Full table, or selected without Files, it is not updated and the sync shows it as failed with a message saying what to change.
>
> Table: `file_deletions` · Primary key: `id` · Sync: Incremental (`detected_at`)
>
> | Field | Type | Description |
> | :- | :- | :- |
> | `id` | String | ID of the deleted recording (joins with `files.id`). |
> | `version` | Integer | Version of the recording in the deletion event. |
> | `deleted_at` | Datetime | When Plaud says the recording was deleted, when it says so (UTC). |
> | `detected_at` | Datetime | When the connector found the deletion (UTC). |
> | `raw` | String | The deletion as Plaud sent it (JSON), or a note from the connector when it found the recording deleted while reading it again. |

> [accordion] Members
>
> Every member of the workspace, including members who were removed. Read in full on every sync.
>
> Table: `members` · Primary key: `id` · Sync: Full table
>
> | Field | Type | Description |
> | :- | :- | :- |
> | `id` | String | Plaud ID of the member. |
> | `workspace_id` | String | ID of the workspace. |
> | `display_name` | String | Name of the member. |
> | `email` | String | Email of the member. |
> | `role` | String | Role of the member in the workspace, such as `admin`. |
> | `active` | Boolean | `false` for members who were removed from the workspace. |
> | `joined_at` | Datetime | When the member joined the workspace (UTC). |

> [accordion] Workspaces
>
> The workspace the credential belongs to (one row). Read in full on every sync.
>
> Table: `workspaces` · Primary key: `workspace_id` · Sync: Full table
>
> | Field | Type | Description |
> | :- | :- | :- |
> | `workspace_id` | String | Plaud ID of the workspace. |
> | `name` | String | Name of the workspace. |
> | `parent_id` | String | ID of the parent workspace, when there is one. |
> | `status` | Boolean | Whether the workspace is active. |
> | `created_at` | Datetime | When the workspace was created (UTC). |

## Implementation Notes

### Data Quality Considerations

* **Consent decides what you get.** Team files are always included. A member's private recordings only appear after that member accepts the consent notice in the Plaud app; they then appear on the next sync, with their full history.
* **Incremental syncs** ask Plaud only for the recordings that changed since the previous successful sync, and read their transcripts and summaries again. If a sync fails, nothing is lost: the next one reads the same changes again, and a long first sync that stops halfway continues after the last recording it completed.
* **Full table on any recording stream re-reads everything.** If Files, File Transcripts or File Summaries is set to Full table, every sync reads every recording and all of its transcripts and summaries. Keep the three streams Incremental.
* **When one recording fails**, for example because Plaud returns an error for its transcript, the other recordings are still loaded, new ones included. That recording is read again on the next syncs (after the new recordings), and the sync shows the affected table as failed until it succeeds. After 10 syncs the connector stops retrying it and tells you in the sync log; it is read again when the recording changes or on a full sync. A sync only stops completely when Plaud refuses the credentials or fails for most of the new recordings.
* **Selecting a new stream later** (for example File Summaries after a while syncing only Files) makes the next sync read every recording once, so the new table gets the full history. Later syncs are incremental again.
* **Deleted recordings.** Rows are not removed from your tables when a recording is deleted in Plaud. When Plaud reports the deletion, the recording gets `is_deleted = true` in Files, or a row in File Deletions when Plaud only sends its ID. A full sync rebuilds the tables from what Plaud currently returns.
* **Summaries that were regenerated** keep their old rows, with an older `file_version`. Join on `file_version` as shown in [Joining transcripts and summaries to recordings](#joining-transcripts-and-summaries-to-recordings).
* **Recordings still being processed** may not have a transcript or summary yet. They are read again on the next syncs. If Plaud does not return the transcript or summary for many recordings in the same sync, the sync stops instead of loading incomplete tables.
* **New or regenerated summaries** are read when Plaud marks the recording as changed (its `version` grows). If Plaud adds a summary without changing the recording, it only arrives with the next change of the recording or with a full sync, which is why a monthly full sync is recommended.
* **Start Date** filters on the date the recording was created in Plaud. Recordings created before it are not extracted, even if they change later.

### API Limits & Performance

* Plaud allows 120 requests per minute for each Client ID, shared with any other tool that uses the same Client ID. The connector stays below that limit and, when Plaud asks it to slow down, waits as long as Plaud says.
* Each recording needs up to two requests (its transcript and its summaries), so a first sync of 1,000 recordings takes roughly 15 to 20 minutes. Later syncs only read the recordings that changed.

## Troubleshooting

| Error or symptom | What it means | What to do |
| :- | :- | :- |
| "Plaud refused the credentials" | The Client ID, private key, API host or token issuer do not match what Plaud registered, or the Enterprise API is not enabled for the workspace. | Check the Client ID and API host Plaud gave you, and that the private key is the pair of the public key you registered. |
| "The Private Key could not be read" | The field does not hold a valid private key (for example the public key was pasted, or part of the file is missing). | Paste the whole `private_key.pem`, including the BEGIN and END lines. |
| "The Private Key is password-protected" | The key was created with a password. | Export it without a password (`openssl pkey -in private_key.pem -out private_key_plain.pem`) and paste that one. |
| "Could not reach Plaud at the API Host configured in this source" | The API host is wrong or not reachable. | Use exactly the API host Plaud gave you, for example `https://api.plaud.ai`. |
| "Plaud refused access to ... (HTTP 403)" | Enterprise API access is not enabled for the workspace. | Ask Plaud to enable the Enterprise API for your Plaud Team workspace. |
| "Plaud is limiting the request rate" | The limit of 120 requests per minute was reached; the connector is waiting. | No action needed. If another tool uses the same Client ID, the syncs take longer. |
| "Plaud did not return ... for N recordings" | Those recordings have no transcript or summary yet. | No action needed; they are read again on the next sync. |
| "Plaud returned an error for N of M recordings" | Plaud failed for those recordings; the others were loaded. | No action needed; they are read again on the next sync. If it repeats, contact Nekt support. |
| "Plaud returned an unexpected response" | The Plaud API changed. | Contact Nekt support. |

## Skills for agents

<Snippet file="agent-skills-intro.mdx" />

> [card] [Download Plaud skills file](https://docs.nekt.com/sources/plaud.md)
>
> Plaud connector documentation as plain markdown, for use in AI agent contexts.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.