> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# Talaridentifiering

> **Note**
>
> **Guide** · Förutsätter att du har slutfört guiden för
> [klientsides-](/docs/sv/eleven-api/guides/how-to/speech-to-text/realtime/client-side-streaming) eller
> [serversides- streaming](/docs/sv/eleven-api/guides/how-to/speech-to-text/realtime/server-side-streaming).

## Översikt

Talaridentifiering tilldelar talar-ID:n till ord så att du kan skilja på vem som sa vad. När talaridentifiering är aktiverad innehåller partiella transkriptioner preliminära talaretiketter, och varje bekräftad transkription följs av en separat `diarized_transcript`-händelse. Talaretiketter kan ändras när mer ljud tas emot.

## Aktivera talaridentifiering

Ange den booleska frågeparametern `diarize=true` när du öppnar en WebSocket-anslutning med `model_id=scribe_v3_live`. Talaridentifiering är som standard `false`.

Följande exempel på serversidan öppnar en anslutning och tar emot händelser. Installera `websockets` för Python, eller `ws` och utvecklingsberoendet `@types/ws` för TypeScript. Ange `ELEVENLABS_API_KEY` i serverns miljö; exemplen skickar den i `xi-api-key`-headern. Behåll den här nyckeln på servern, inte i webbläsarkod.

De här exemplen skickar inte ljud. Integrera dem med din ljudproducent från [guiden för streaming på serversidan](/docs/sv/eleven-api/guides/how-to/speech-to-text/realtime/server-side-streaming): skicka `input_audio_chunk`-meddelanden på samma anslutning medan du tar emot händelser. Exemplen väljer `pcm_16000`, så använd matchande ljud. I Python kör du uppgiften som skickar ljud samtidigt som mottagningsloopen; i TypeScript skickar du ljud efter att anslutningen har öppnats.

```python
import asyncio
import json
import os

from websockets.asyncio.client import connect


async def main():
    url = (
        "wss://api.elevenlabs.io/v1/speech-to-text/realtime"
        "?model_id=scribe_v3_live&audio_format=pcm_16000&diarize=true"
    )
    headers = {"xi-api-key": os.environ["ELEVENLABS_API_KEY"]}

    async with connect(url, additional_headers=headers) as websocket:
        async for message in websocket:
            event = json.loads(message)
            print(event)


if __name__ == "__main__":
    asyncio.run(main())
```

```typescript
import WebSocket from "ws";

const apiKey = process.env.ELEVENLABS_API_KEY;
if (!apiKey) {
  throw new Error("Set ELEVENLABS_API_KEY in your server environment.");
}

const websocket = new WebSocket(
  "wss://api.elevenlabs.io/v1/speech-to-text/realtime" +
    "?model_id=scribe_v3_live&audio_format=pcm_16000&diarize=true",
  { headers: { "xi-api-key": apiKey } }
);

websocket.on("message", (message) => {
  const event = JSON.parse(message.toString());
  console.log(event);
});

websocket.on("error", (error) => {
  console.error(error);
});
```

## Hantera händelser

### Partiella transkriptioner

När talaridentifiering är aktiverad innehåller varje `partial_transcript` preliminära `words` i samma ordformat som batchtranskribering. Varje ords `speaker_id` är `speaker_0`, `speaker_1` och så vidare när en talare har identifierats, eller `null` medan det fortfarande är oklart.

Behandla dessa ord som preliminära: talar-ID:n och tidsstämplar kan ändras när mer ljud tillkommer. Ord som ännu inte har justerats saknar tidsstämplar (`start` och `end` är `null` eller saknas).

### Bekräftade och talaridentifierade transkriptioner

Talaridentifiering fördröjer inte `committed_transcript`. När talaridentifiering är aktiverad lägger den här händelsen till det nollbaserade heltalet `segment_index`:

```json
{
  "message_type": "committed_transcript",
  "segment_index": 0,
  "text": "Hello."
}
```

Varje bekräftelse följs av en separat `diarized_transcript`-händelse med matchande `segment_index`, `text` och `words`:

```json
{
  "message_type": "diarized_transcript",
  "segment_index": 0,
  "text": "Hello.",
  "words": [
    {
      "text": "Hello.",
      "speaker_id": "speaker_0"
    }
  ]
}
```

Ordet ovan visar bara texten och talaretiketten. Det fullständiga ordformatet använder samma fält för `start`, `end`, `type`, `logprob` och `characters` som batchtranskribering, tillsammans med `speaker_id`. En oidentifierad talare har ett `null`-talar-ID.

Talaridentifierade transkriptioner skickas i bekräftelseordning. Koppla dem till bekräftade transkriptioner med `segment_index`, i stället för text eller nästa mottagna händelse. En `diarized_transcript` skickas alltid för varje bekräftelse, även om talaridentifieringen misslyckas; i så fall är oidentifierade talar-ID:n `null`.

### Sammanslagningar av talare

En `speakers_merged`-händelse innebär att två talar-ID:n hänvisar till samma person:

```json
{
  "message_type": "speakers_merged",
  "from_speaker_id": "speaker_1",
  "to_speaker_id": "speaker_0"
}
```

Ersätt varje tidigare användning av `from_speaker_id` med `to_speaker_id` i både partiella och talaridentifierade transkriptioner. Talar-ID:n återanvänds aldrig. Sammanslagningar kan kedjas, så tillämpa dem i mottagningsordning: om `speaker_2` slås samman med `speaker_1` och sedan `speaker_1` slås samman med `speaker_0`, måste alla tidigare ord från båda ID:na märkas som `speaker_0`.

Anropa till exempel den här hanteraren för varje mottagen händelse. Här lagrar `transcript_history` varje partiell och talaridentifierad transkription som programmet behåller, inklusive tidigare partiella ögonblicksbilder. Varje sammanslagning uppdaterar alla lagrade ord direkt, så kedjade sammanslagningar uppdaterar också tidigare sammanslagna ord. Återge talaretiketter från den här uppdaterade lagringen; `null`-etiketter förblir `null`.

```python
transcript_history = []


def handle_event(event):
    if event["message_type"] in ("partial_transcript", "diarized_transcript"):
        transcript_history.append(event)
    elif event["message_type"] == "speakers_merged":
        for transcript in transcript_history:
            for word in transcript.get("words") or []:
                if word.get("speaker_id") == event["from_speaker_id"]:
                    word["speaker_id"] = event["to_speaker_id"]
```

## Begränsningar

* Talaridentifiering stöds endast av `scribe_v3_live`. Andra modeller returnerar felet `invalid_request` med meddelandet `"The 'diarize' parameter is only supported by scribe_v3_live."` och stänger sedan anslutningen.
* Talaridentifiering kan inte kombineras med `filter_background_audio`. Den här kombinationen returnerar felet `invalid_request` med ett meddelande som innehåller `"cannot be combined with filter_background_audio"` och stänger sedan anslutningen.
* Talaretiketter kan förbli oidentifierade (`null`), och senare `speakers_merged`-händelser kan ändra tidigare etiketter. Dessa sammanslagningshändelser skickas endast när talaridentifiering är aktiverad.