> 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.

# Dynamiska variabler

**Dynamiska variabler** låter dig infoga körningsvärden i agentens meddelanden, systemprompter och verktyg. Det gör att du kan anpassa varje konversation med användarspecifik data utan att skapa flera agenter.

## Översikt

Dynamiska variabler kan användas i flera delar av din agent:

* **Systemprompter** för att anpassa beteende och kontext
* **Första meddelanden** för att anpassa hälsningar
* **Verktygsparametrar och headers** för att skicka användarspecifik data

Här är några exempel där dynamiska variabler är användbara:

* **Anpassa hälsningar** med användarnamn
* **Inkludera kontouppgifter** i svar
* **Skicka data** till verktygsanrop
* **Anpassa beteende** utifrån prenumerationsnivåer
* **Få åtkomst till systeminformation** som konversations-ID eller samtalslängd

> **Info**
>
> Dynamiska variabler är perfekta för att infoga användarspecifik data som inte bör hårdkodas i
> agentens konfiguration.

## Systemets dynamiska variabler

Din agent har åtkomst till dessa automatiskt tillgängliga systemvariabler:

* `system__agent_id` - Unik identifierare för agenten som initierade konversationen (förblir densamma under hela konversationen)
* `system__current_agent_id` - Unik identifierare för den aktiva agenten (ändras efter agentöverföringar)
* `system__caller_id` - Uppringarens telefonnummer (endast röstsamtal)
* `system__called_number` - Mottagarens telefonnummer (endast röstsamtal)
* `system__call_duration_secs` - Samtalslängd i sekunder
* `system__time_utc` - Aktuell UTC-tid (ISO-format)
* `system__time` - Aktuell tid i den angivna tidszonen (lättläst format, t.ex. "fredag, 12:33 12 december 2025")
* `system__timezone` - Användarangiven tidszon (måste vara giltig för tzinfo)
* `system__conversation_id` - ElevenLabs unika konversationsidentifierare
* `system__call_sid` - Samtals-SID (endast Twilio-samtal)
* `system__call_id` - Unik identifierare för SIP-trunksamtalet (endast SIP-trunksamtal)
* `system__agent_turns` - Det totala antalet konversationsomgångar som agenten har gjort under den här konversationen.
* `system__current_agent_turns` - Antalet konversationsomgångar som den aktuella agenten har gjort. Återställs när konversationen överförs till en annan agent.
* `system__current_subagent_turns` - Antalet konversationsomgångar som den aktuella underagenten har gjort. Återställs när arbetsflödet övergår till en annan nod.
* `system__is_text_only` - True om konversationen körs i enbart textläge, annars false.
* `system__conversation_history` - JSON-serialiserad representation av den aktuella konversationshistoriken. Utvärderas först när den refereras. Se [formatinformation](#conversation-history-format) nedan.

Systemvariabler:

* Är tillgängliga utan körningskonfiguration
* Har prefixet `system__` (reserverat prefix)
* Uppdateras automatiskt under hela konversationen

> **Warning**
>
> Anpassade dynamiska variabler kan inte använda det reserverade prefixet `system__`.

### Konversationshistorikens format

Variabeln `system__conversation_history` innehåller ett JSON-objekt med följande struktur:

```json
{
  "x-elevenlabs-history": true,
  "entries": [
    { "role": "user", "message": "Hello" },
    { "role": "agent", "message": "Hi, how can I help?" },
    {
      "role": "agent",
      "tool_requests": [{ "tool_name": "lookup_order", "params_as_json": { "order_id": "123" } }]
    },
    {
      "role": "tool",
      "tool_results": [{ "tool_name": "lookup_order", "result_value": "{\"status\": \"shipped\"}" }]
    }
  ]
}
```

Varje post innehåller en `role` (`"user"`, `"agent"` eller `"tool"`) och ett av följande:

* `message` — omgångens textinnehåll
* `tool_requests` — en array med verktygsanrop som agenten har gjort, med lösta parametervärden
* `tool_results` — en array med verktygssvar

Om ett verktygsresultat eller en parameter innehåller en kapslad konversationshistorik maskeras den som en platshållare (t.ex. `[conversation_history (5 turns)]`) för att undvika obegränsad rekursiv expansion.

Den här variabeln är användbar för att skicka konversationskontext till verktyg (t.ex. webhooks, anpassade LLM:er) eller för att inkludera konversationshistorik i underagentprompter vid överlämningar.

## Hemliga dynamiska variabler

Hemliga dynamiska variabler fylls i på samma sätt som vanliga dynamiska variabler, men visar för våra ElevenAgents att de
endast ska användas i headers för dynamiska variabler och aldrig skickas till en LLM-leverantör som en del av agentens systemprompt eller första meddelande.

Vi rekommenderar att du använder dem för autentiseringstoken eller privata ID:n som inte ska skickas till en LLM. För att skapa en hemlig dynamisk variabel lägger du bara till prefixet `secret__` framför den dynamiska variabeln.

> **Warning**
>
> Hemliga värden returneras maskerade som `<REDACTED>`, även i webhooks efter samtalet och
> Conversations API. Använd inte prefixet `secret__` för värden som du behöver läsa tillbaka efter
> konversationen. Skicka dem som vanliga dynamiska variabler, eller skicka en icke-känslig identifierare och slå
> upp det känsliga värdet i ditt eget system.

## Uppdatera dynamiska variabler från verktyg

[Verktygsanrop](https://elevenlabs.io/docs/eleven-agents/customization/tools) kan skapa eller uppdatera dynamiska variabler om de returnerar ett giltigt JSON-objekt. Ange objektsökvägarna med punktnotation för att specificera vad som ska extraheras. Om fältet eller sökvägen inte finns uppdateras ingenting.

Exempel på ett svarsobjekt och punktnotation:

* Status motsvarar sökvägen: `response.status`
* Den första användarens e-postadress i users-arrayen motsvarar sökvägen: `response.users.0.email`

**`JSON`**

```JSON title="JSON"
{
  "response": {
    "status": 200,
    "message": "Successfully found 5 users",
    "users": [
      "user_1": {
        "user_name": "test_user_1",
        "email": "test_user_1@email.com"
      }
    ]
  }
}
```

Om du vill uppdatera en dynamisk variabel till den första användarens e-postadress anger du tilldelningen så här.

![Frågeparametrar](/docs/_fern-img/95ff0cae8613eafa8bc4312e7cafa39ac0eab34d2fd2b21f0894a30775366110.webp)

Tilldelningar är ett fält för varje webhook-verktyg och dokumenteras [här](/docs/sv/eleven-agents/api-reference/tools/create#response.body.tool_config.SystemToolConfig.assignments).

## Guide

### Förutsättningar

* Ett [ElevenLabs-konto](https://elevenlabs.io)
* En konfigurerad ElevenLabs Conversational Agent ([skapa en här](/docs/sv/eleven-agents/quickstart))

#### Definiera dynamiska variabler i prompter

Lägg till variabler med dubbla klammerparenteser `{{variable_name}}` i dina:

* Systemprompter
* Första meddelanden
* Verktygsparametrar

![Dynamiska variabler i meddelanden](/docs/_fern-img/84a9870018a436215fe8d6563a47f42b1b45e005c56dffff3b37dbfe8a25adf3.webp)

![Dynamiska variabler i meddelanden](/docs/_fern-img/052ab733ff3ecb2512218c70d82a4337764577b0082cdc4b2fb4415d273d2cbe.webp)

#### Definiera dynamiska variabler i verktyg

Du kan också definiera dynamiska variabler i verktygskonfigurationen.
Om du vill skapa en ny dynamisk variabel anger du värdetypen till Dynamic variable och klickar på knappen `+`.

![Ange platshållare](/docs/_fern-img/7da35479f409f1505dc528e78d782d74e226fa51b2a5d3b6ede3929359be8ddd.webp)

![Ange platshållare](/docs/_fern-img/21856929c95fe77b274dc1a849668c144554719cd468a225d110295ae94c7713.webp)

#### Ange platshållare

Konfigurera standardvärden för testning utan att skicka variabler vid körning.

#### Uppdatera via instrumentpanelen

Ange standardvärden för varje dynamisk variabel på agentens instrumentpanel.

![Ange platshållare](/docs/_fern-img/dbea803919e315240202a3cb355ef7f62f25a5182d9aa99d0916177349c70ae4.webp)

#### Uppdatera via CLI

#### Hämta agentkonfigurationen

```bash
elevenlabs agents pull --agent "<agent-name>"
```

#### Redigera \`agent\_configs/\<agent-name>.json\`

Ange `conversation_config.agent.dynamic_variables.dynamic_variable_placeholders`. Varje nyckel är variabelnamnet och värdet är platshållaren som används vid testning:

```json
{
  "conversation_config": {
    "agent": {
      "dynamic_variables": {
        "dynamic_variable_placeholders": {
          "user_name": "Angelo",
          "account_type": "premium"
        }
      }
    }
  }
}
```

#### Skicka dina ändringar

```bash
elevenlabs agents push --agent "<agent-name>"
```

#### Uppdatera via API

```python
from elevenlabs import ElevenLabs

elevenlabs = ElevenLabs()

elevenlabs.conversational_ai.agents.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    conversation_config={
        "agent": {
            "dynamic_variables": {
                "dynamic_variable_placeholders": {
                    "user_name": "Angelo",
                    "account_type": "premium",
                }
            }
        },
    },
)
```

```typescript
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const elevenlabs = new ElevenLabsClient();

await elevenlabs.conversationalAi.agents.update("agent_7101k5zvyjhmfg983brhmhkd98n6", {
  conversationConfig: {
    agent: {
      dynamicVariables: {
        dynamicVariablePlaceholders: {
          user_name: "Angelo",
          account_type: "premium",
        },
      },
    },
  },
});
```

#### Skicka variabler vid körning

När du startar en konversation anger du de dynamiska variablerna i din kod:

> **Tip**
>
> Kontrollera att du har den senaste [SDK:n](/docs/sv/eleven-agents/libraries/python) installerad.

**`Python`**

```python title="Python" focus={10-23} maxLines=25
import os
import signal
from elevenlabs.client import ElevenLabs
from elevenlabs.conversational_ai.conversation import Conversation, ConversationInitiationData
from elevenlabs.conversational_ai.default_audio_interface import DefaultAudioInterface

agent_id = os.getenv("AGENT_ID")
api_key = os.getenv("ELEVENLABS_API_KEY")
elevenlabs = ElevenLabs(api_key=api_key)

dynamic_vars = {
    "user_name": "Angelo",
}

config = ConversationInitiationData(
    dynamic_variables=dynamic_vars
)

conversation = Conversation(
    elevenlabs,
    agent_id,
    config=config,
    # Assume auth is required when API_KEY is set.
    requires_auth=bool(api_key),
    # Use the default audio interface.
    audio_interface=DefaultAudioInterface(),
    # Simple callbacks that print the conversation to the console.
    callback_agent_response=lambda response: print(f"Agent: {response}"),
    callback_agent_response_correction=lambda original, corrected: print(f"Agent: {original} -> {corrected}"),
    callback_user_transcript=lambda transcript: print(f"User: {transcript}"),
    # Uncomment the below if you want to see latency measurements.
    # callback_latency_measurement=lambda latency: print(f"Latency: {latency}ms"),
)

conversation.start_session()

signal.signal(signal.SIGINT, lambda sig, frame: conversation.end_session())
```

**`JavaScript`**

```javascript title="JavaScript" focus={7-20} maxLines=25
import { Conversation } from '@elevenlabs/client';

class VoiceAgent {
  ...

  async startConversation() {
    try {
        // Request microphone access
        await navigator.mediaDevices.getUserMedia({ audio: true });

        this.conversation = await Conversation.startSession({
            agentId: 'agent_id_goes_here', // Replace with your actual agent ID

            dynamicVariables: {
                user_name: 'Angelo'
            },

            ... add some callbacks here
        });
    } catch (error) {
        console.error('Failed to start conversation:', error);
        alert('Failed to start conversation. Please ensure microphone access is granted.');
    }
  }
}
```

**`Swift`**

```swift title="Swift"
let dynamicVars: [String: DynamicVariableValue] = [
  "customer_name": .string("John Doe"),
  "account_balance": .number(5000.50),
  "user_id": .int(12345),
  "is_premium": .boolean(true)
]

// Create session config with dynamic variables
let config = SessionConfig(
    agentId: "agent_7101k5zvyjhmfg983brhmhkd98n6",
    dynamicVariables: dynamicVars
)

// Start the conversation
let conversation = try await Conversation.startSession(
    config: config
)
```

**`Widget`**

```html title="Widget"
<elevenlabs-convai
  agent-id="agent_7101k5zvyjhmfg983brhmhkd98n6"
  dynamic-variables='{"user_name": "John", "account_type": "premium"}'
></elevenlabs-convai>
```

## Integrering med offentlig Talk-to-sida

Den offentliga Talk-to-sidan stöder dynamiska variabler via URL-parametrar, vilket gör att du kan anpassa konversationer när du delar agentlänkar. Det är särskilt användbart när du bäddar in anpassade agenter på webbplatser, i e-postmeddelanden eller i marknadsföringskampanjer.

### Metoder för URL-parametrar

Det finns två metoder för att skicka dynamiska variabler till den offentliga Talk-to-sidan:

#### Metod 1: Base64-kodad JSON

Skicka variabler som ett base64-kodat JSON-objekt med parametern `vars`:

```
https://elevenlabs.io/app/talk-to?agent_id=agent_7101k5zvyjhmfg983brhmhkd98n6&vars=eyJ1c2VyX25hbWUiOiJKb2huIiwiYWNjb3VudF90eXBlIjoicHJlbWl1bSJ9
```

Parametern `vars` innehåller base64-kodad JSON:

```json
{ "user_name": "John", "account_type": "premium" }
```

#### Metod 2: Enskilda frågeparametrar

Skicka variabler med frågeparametrar som har prefixet `var_`:

```
https://elevenlabs.io/app/talk-to?agent_id=agent_7101k5zvyjhmfg983brhmhkd98n6&var_user_name=John&var_account_type=premium
```

### Parameterprioritet

När båda metoderna används samtidigt har enskilda `var_`-parametrar företräde framför de base64-kodade variablerna för att undvika konflikter:

```
https://elevenlabs.io/app/talk-to?agent_id=agent_7101k5zvyjhmfg983brhmhkd98n6&vars=eyJ1c2VyX25hbWUiOiJKYW5lIn0=&var_user_name=John
```

I det här exemplet blir `user_name` "John" (från `var_user_name`) i stället för "Jane" (från de base64-kodade `vars`).

### Implementeringsexempel

#### Generera JavaScript-URL

```javascript
// Method 1: Base64-encoded JSON
function generateTalkToURL(agentId, variables) {
  const baseURL = 'https://elevenlabs.io/app/talk-to';
  const encodedVars = btoa(JSON.stringify(variables));
  return `${baseURL}?agent_id=${agentId}&vars=${encodedVars}`;
}

// Method 2: Individual parameters
function generateTalkToURLWithParams(agentId, variables) {
  const baseURL = 'https://elevenlabs.io/app/talk-to';
  const params = new URLSearchParams({ agent_id: agentId });

  Object.entries(variables).forEach(([key, value]) => {
    params.append(`var_${key}`, encodeURIComponent(value));
  });

  return `${baseURL}?${params.toString()}`;
}

// Usage
const variables = {
  user_name: "John Doe",
  account_type: "premium",
  session_id: "sess_123"
};

const urlMethod1 = generateTalkToURL("agent_7101k5zvyjhmfg983brhmhkd98n6", variables);
const urlMethod2 = generateTalkToURLWithParams("agent_7101k5zvyjhmfg983brhmhkd98n6", variables);
```

#### Generera Python-URL

```python
import base64
import json
from urllib.parse import urlencode, quote

def generate_talk_to_url(agent_id, variables):
    """Generate URL with base64-encoded variables"""
    base_url = "https://elevenlabs.io/app/talk-to"
    encoded_vars = base64.b64encode(json.dumps(variables).encode()).decode()
    return f"{base_url}?agent_id={agent_id}&vars={encoded_vars}"

def generate_talk_to_url_with_params(agent_id, variables):
    """Generate URL with individual var_ parameters"""
    base_url = "https://elevenlabs.io/app/talk-to"
    params = {"agent_id": agent_id}

    for key, value in variables.items():
        params[f"var_{key}"] = value

    return f"{base_url}?{urlencode(params)}"

# Usage
variables = {
    "user_name": "John Doe",
    "account_type": "premium",
    "session_id": "sess_123"
}

url_method1 = generate_talk_to_url("agent_7101k5zvyjhmfg983brhmhkd98n6", variables)
url_method2 = generate_talk_to_url_with_params("agent_7101k5zvyjhmfg983brhmhkd98n6", variables)
```

#### Manuell URL-konstruktion

```
# Base64-encoded method
1. Create JSON: {"user_name": "John", "account_type": "premium"}
2. Encode to base64: eyJ1c2VyX25hbWUiOiJKb2huIiwiYWNjb3VudF90eXBlIjoicHJlbWl1bSJ9
3. Add to URL: https://elevenlabs.io/app/talk-to?agent_id=agent_7101k5zvyjhmfg983brhmhkd98n6&vars=eyJ1c2VyX25hbWUiOiJKb2huIiwiYWNjb3VudF90eXBlIjoicHJlbWl1bSJ9

# Individual parameters method
1. Add each variable with var_ prefix
2. URL encode values if needed
3. Final URL: https://elevenlabs.io/app/talk-to?agent_id=agent_7101k5zvyjhmfg983brhmhkd98n6&var_user_name=John&var_account_type=premium
```

## Typer som stöds

Dynamiska variabler stöder följande värdetyper:

#### Sträng

Textvärden

#### Tal

Numeriska värden

#### Boolesk

True/false-värden

## Felsökning

#### Variabler ersätts inte

Kontrollera att:

* Variabelnamnen matchar exakt (skiftlägeskänsliga)
* Variabler använder dubbla klammerparenteser: `{{ variable_name }}`
* Variablerna ingår i ditt dynamic\_variables-objekt

#### Typfel

Kontrollera att:

* Variabelvärdena matchar den förväntade typen
* Värdena endast är strängar, tal eller booleska värden