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

# Snabbstart för Image & Video

Image & Video API är asynkront. Du skickar in en generering och laddar ned resultatet från en signerad URL när den är klar. Bilder och videor har separata slutpunkter, men strukturen för begäran och svaret är densamma för båda.

Det finns två sätt att hämta resultatet. [Webhook-leverans](/docs/sv/eleven-api/guides/how-to/image-and-video/webhooks) är det rekommenderade alternativet och används i exemplen nedan: ElevenLabs anropar din slutpunkt när en generering når en slutgiltig status, så ingen tid går åt till väntan. Pollning är ett alternativ när du inte har någon slutpunkt som kan ta emot en callback, och varje exempel visar hur du använder det i stället.

> **Warning**
>
> Image & Video API kräver Pro-planen eller högre. Anrop från en arbetsyta under den nivån
> avvisas med felet `402 paid_plan_required`. Din API-nyckel måste också ha behörigheten Image & Video eller
> Flows för arbetsytan.

## Generera en bild

#### Skapa en API-nyckel

[Skapa en API-nyckel i kontrollpanelen här](https://elevenlabs.io/app/settings/api-keys), som du använder för att säkert [få åtkomst till API:et](/docs/sv/api-reference/authentication).

Spara nyckeln som en hanterad hemlighet och skicka den till SDK:erna antingen som en miljövariabel via en `.env`-fil eller direkt i appens konfiguration, beroende på vad du föredrar.

**`.env`**

```js title=".env"
ELEVENLABS_API_KEY=<your_api_key_here>
```

#### Installera SDK:t

#### SDK

Vi använder också biblioteket `dotenv` för att läsa in vår API-nyckel från en miljövariabel.

```python
pip install elevenlabs
pip install python-dotenv
```

```typescript
npm install @elevenlabs/elevenlabs-js
npm install dotenv
```

#### CLI

Installera ElevenLabs CLI. Homebrew (macOS) och Scoop (Windows) rekommenderas.

**`Homebrew (macOS)`**

```bash title="Homebrew (macOS)"
brew install elevenlabs/tap/elevenlabs
```

**`Scoop (Windows)`**

```powershell title="Scoop (Windows)"
scoop bucket add elevenlabs https://github.com/elevenlabs/scoop-bucket
scoop install elevenlabs
```

**`npm`**

```bash title="npm"
npm install -g @elevenlabs/cli
```

**`curl`**

```bash title="curl"
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/elevenlabs/cli/releases/latest/download/elevenlabs-cli-installer.sh | sh
```

> **Tip**
>
> Arbetar du med en AI-kodningsassistent? Kör `elevenlabs generate-skills` i ditt projekt för att skapa en
> `SKILL.md` för varje kommandogrupp i `skills/`, så att assistenten känner till hela CLI:ts yta
> utan att du behöver klistra in dokumentation. Använd `--output-dir` för att lägga dem någon annanstans. Detta läser CLI:ts egen
> inbäddade API-definition, så det kräver ingen API-nyckel och fungerar offline — och det följer
> den version av CLI:t som du har installerad.

Autentisera sedan — detta öppnar webbläsaren så att du kan auktorisera CLI:t:

```bash
elevenlabs auth login
```

#### Skicka in genereringen

Varje modell har sin egen begärandeklass, och dess fält är de parametrar som modellen
accepterar. Att byta modell kan därför ändra vilka fält som är tillgängliga. Okända fält avvisas
i stället för att ignoreras.

`webhook` begär att det färdiga resultatet levereras till arbetsytans webhooks, så anropet
returnerar så snart genereringen har köats. Det kräver en webhook som prenumererar på genererings-
händelser; se [Image & Video- webhooks](/docs/sv/eleven-api/guides/how-to/image-and-video/webhooks) för att konfigurera en, eller utelämna
fältet och polla i stället.

#### SDK

```python
# example.py
import os

from dotenv import load_dotenv
from elevenlabs import ImageGenerationRequest_Gemini3ProImage, WebhookTarget_All
from elevenlabs.client import ElevenLabs

load_dotenv()

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

generation = elevenlabs.flows.image.create(
    request=ImageGenerationRequest_Gemini3ProImage(
        prompt="A corgi in a tiny lifeguard chair on a sunlit beach at golden hour, photorealistic",
        aspect_ratio="16:9",
        resolution="2K",
        webhook=WebhookTarget_All(),
    )
)

print(generation.id, generation.status)
```

```typescript
// example.mts
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import "dotenv/config";

const elevenlabs = new ElevenLabsClient();

const generation = await elevenlabs.flows.image.create({
  modelId: "gemini-3-pro-image",
  prompt:
    "A corgi in a tiny lifeguard chair on a sunlit beach at golden hour, photorealistic",
  aspectRatio: "16:9",
  resolution: "2K",
  webhook: { type: "all" },
});

console.log(generation.id, generation.status);
```

#### CLI

CLI:t skickar samma begäran som JSON, pollar sedan tills genereringen är klar och laddar ned resultatet:

```bash
# 1. Submit the generation (note the returned id)
elevenlabs flows image create --json '{
  "model_id": "gemini-3-pro-image",
  "prompt": "A corgi in a tiny lifeguard chair on a sunlit beach at golden hour, photorealistic",
  "aspect_ratio": "16:9",
  "resolution": "2K"
}'

# 2. Poll until the status is "completed"
elevenlabs flows image get --generation-id <id> --query status

# 3. Read the signed content URL, then download the image
elevenlabs flows image get --generation-id <id> --query content_url
curl -o corgi.png "<content_url>"
```

Svaret innehåller genererings-ID:t och inget annat. En nyligen skapad generering är alltid
`pending`:

```json
{
  "id": "JWr5N6X9ZTqf8jD2LmQb",
  "status": "pending"
}
```

#### Hämta resultatet

Eftersom begäran använde `webhook` skickar ElevenLabs en `flows_generation`-händelse till din
slutpunkt när genereringen når `completed` eller `failed`. Händelsens `data` är identisk med
vad GET-slutpunkten returnerar, och
[Image & Video-webhooks](/docs/sv/eleven-api/guides/how-to/image-and-video/webhooks) beskriver
hanteraren som tar emot den.

Om du inte har en slutpunkt som kan ta emot callbacks tar du bort `webhook` från begäran ovan och pollar i stället.
Hämta genereringen tills statusen är `completed` eller `failed`, och vänta minst två sekunder
mellan bildbegäranden – se [Riktlinjer för pollning](#polling-guidelines) för intervallen
per modalitet.

```python maxLines=0
import time

import requests

while True:
    result = elevenlabs.flows.image.get(generation.id)
    if result.status in ("completed", "failed"):
        break
    time.sleep(2)

if result.status == "failed":
    raise RuntimeError(f"{result.failure_reason}: {result.error_message}")

with open("corgi.png", "wb") as f:
    f.write(requests.get(result.content_url).content)
```

```typescript maxLines=0
import { writeFile } from "fs/promises";

let result = await elevenlabs.flows.image.get(generation.id);

while (result.status === "pending" || result.status === "generating") {
  await new Promise((resolve) => setTimeout(resolve, 2000));
  result = await elevenlabs.flows.image.get(generation.id);
}

if (result.status === "failed") {
  throw new Error(`${result.failureReason}: ${result.errorMessage}`);
}

const response = await fetch(result.contentUrl);
await writeFile("corgi.png", Buffer.from(await response.arrayBuffer()));
```

Oavsett metod innehåller en slutförd generering samma fält:

```json
{
  "id": "JWr5N6X9ZTqf8jD2LmQb",
  "status": "completed",
  "content_url": "https://storage.googleapis.com/generations/JWr5N6X9ZTqf8jD2LmQb",
  "content_mime_type": "image/png"
}
```

#### Kör koden

```python
python example.py
```

```typescript
npx tsx example.mts
```

Genereringen köas och dess ID skrivs ut. Med webhook-leverans kommer bilden till din
slutpunkt; med pollningsvarianten sparas den som `corgi.png`.

## Generera en video

Videogenereringar använder `flows.video` och följer samma mönster för att skicka in och hämta resultat. En video kan ta
flera minuter, så det här exemplet använder webhook-leverans med `webhook` i stället för att vänta på
resultatet.

```python
from elevenlabs import VideoGenerationRequest_Veo31FastGenerate001, WebhookTarget_All

generation = elevenlabs.flows.video.create(
    request=VideoGenerationRequest_Veo31FastGenerate001(
        prompt="A corgi rides a tiny surfboard across a sunlit wave at golden hour, cinematic",
        duration_secs=8,
        aspect_ratio="16:9",
        resolution="1080p",
        generate_audio=True,
        webhook=WebhookTarget_All(),
    )
)

print(generation.id)
```

```typescript
const generation = await elevenlabs.flows.video.create({
  modelId: "veo-3.1-fast-generate-001",
  prompt: "A corgi rides a tiny surfboard across a sunlit wave at golden hour, cinematic",
  durationSecs: 8,
  aspectRatio: "16:9",
  resolution: "1080p",
  generateAudio: true,
  webhook: { type: "all" },
});

console.log(generation.id);
```

Anropet returnerar så snart genereringen har köats och det färdiga resultatet levereras till varje
webhook i din arbetsyta som prenumererar på genereringshändelser. Videoutdata är MP4, så den slutförda nyttolasten rapporterar en
`content_mime_type` på `video/mp4`. Se
[Image & Video-webhooks](/docs/sv/eleven-api/guides/how-to/image-and-video/webhooks) för att konfigurera en
webhook och skriva hanteraren som tar emot detta.

> **Warning**
>
> `webhook` kräver minst en webhook i arbetsytan som prenumererar på genereringshändelser. Utan en sådan
> avvisas anropet för att skapa en generering i stället för att starta en generering vars resultat inte har någonstans att ta vägen. Ta bort
> fältet för att i stället polla med `flows.video.get`, och polla högst en gång var tionde
> sekund.

## Hämta resultat

Webhooks och pollning returnerar samma nyttolast, så valet handlar om hur du väntar på den snarare än
vad du får.

|                    | Webhook-leverans                                            | Pollning                                    |
| ------------------ | ----------------------------------------------------------- | ------------------------------------------- |
| Bäst för           | Standardvalet för båda modaliteterna och all produktion     | Skript och miljöer utan offentlig slutpunkt |
| Kräver             | En HTTPS-slutpunkt som prenumererar på genereringshändelser | Ingenting                                   |
| Kostnad för väntan | Ingen; du anropas när genereringen är klar                  | En begäran per pollning, per generering     |

Använd webhooks när du kan. Välj pollning när du inte har någonstans att ta emot en callback, och
följ intervallen nedan när du gör det.

### Välja webhook-mål

`webhook` accepterar två former. `WebhookTarget_All` når varje webhook som prenumererar på genererings-
händelser, vilket är rätt standardval eftersom det fungerar även om webhooks roteras eller ersätts.
`WebhookTarget_Ids` begränsar leveransen till specifika webhooks, när en arbetsyta distribuerar till flera
konsumenter och ett visst jobb bara ska nå en av dem:

```python
from elevenlabs import WebhookTarget_Ids

webhook = WebhookTarget_Ids(ids=["Q8mVr2LpXcT4nB6yJdKw"])
```

```typescript
const webhook = { type: "ids", ids: ["Q8mVr2LpXcT4nB6yJdKw"] };
```

Varje ID måste redan prenumerera på genereringshändelser; att ange en webhook utan prenumeration
avvisas i stället för att tyst ignoreras. Den levererade nyttolasten är identisk med vad GET-slutpunkten
returnerar, så en hanterare som skrivits för den ena fungerar även för den andra. I
[webhook-guiden](/docs/sv/eleven-api/guides/how-to/image-and-video/webhooks) beskrivs hur du konfigurerar en
webhook, verifierar signaturen och hanterar händelsen.

### Riktlinjer för pollning

En genererings körtid beror på modellen, upplösningen och, för video, längden. Polla därför
med ett intervall som motsvarar vad du har begärt i stället för i en fast loop:

* **Bilder**: polla högst en gång varannan sekund. De flesta blir klara inom några sekunder.
* **Video**: polla högst en gång var tionde sekund. Räkna med minuter, inte sekunder, och anpassa
  intervallet efter `duration_secs` och `resolution`.

Två regler gäller för båda. Backa när en generering tar lång tid – att fördubbla intervallet upp till ungefär en
minut hindrar en långsam generering från att resultera i hundratals begäranden. Och sätt en övre gräns för loopen,
så att en fastnad generering avslutas med en timeout i din egen kod i stället för en obegränsad loop.

Att polla snabbare ger dig inget: en genererings status ändras inte snabbare för att
du frågar två gånger. Ihållande aggressiv pollning kan returnera
[429-svar](/docs/sv/eleven-api/resources/errors#rate-limiting-and-concurrency), som du bör
hantera med exponentiell backoff.

## Genereringens livscykel

En generering går igenom fyra statusar. De två slutgiltiga statusarna innehåller olika fält, så
kontrollera `status` innan du läser resten av svaret.

| Status       | Betydelse                                                                      |
| ------------ | ------------------------------------------------------------------------------ |
| `pending`    | Genereringen är köad. Detta är statusen för alla nyligen skapade genereringar. |
| `generating` | Modellen körs.                                                                 |
| `completed`  | Resultatet är klart. Svaret innehåller `content_url` och `content_mime_type`.  |
| `failed`     | Genereringen skapade inget resultat. Svaret innehåller information om felet.   |

> **Warning**
>
> `content_url` är en signerad URL som upphör att gälla ungefär en timme efter att svaret har returnerats. Hämta
> genereringen igen för en ny URL i stället för att lagra den signerade URL:en.

## Hantera fel

En misslyckad generering rapporterar kategorin `failure_reason` tillsammans med ett läsbart `error_message`:

```json
{
  "id": "JWr5N6X9ZTqf8jD2LmQb",
  "status": "failed",
  "failure_reason": "moderated",
  "error_message": "The prompt was rejected by content moderation. You were not charged for this generation."
}
```

| `failure_reason`     | Orsak                                                                |
| -------------------- | -------------------------------------------------------------------- |
| `timeout`            | Modellen returnerade inte ett resultat i tid.                        |
| `model_error`        | Modellleverantören returnerade ett fel eller skapade inget resultat. |
| `moderated`          | Prompten eller en inmatning avvisades av innehållsmodereringen.      |
| `invalid_parameters` | Parametrarna avvisades när genereringen nådde modellen.              |
| `dependency_failed`  | En refererad generering som denna är beroende av misslyckades.       |
| `charging_failed`    | Arbetsytan kunde inte debiteras för genereringen.                    |
| `internal_error`     | Ett oväntat fel inträffade.                                          |

Misslyckade genereringar debiteras inte. Parameterproblem som kan upptäckas direkt – ett
fält som inte stöds, ett värde utanför modellens tillåtna intervall eller en ogiltig kombination av referens-
inmatningar – avvisas i stället av begäran om att skapa en generering, innan någon generering startar.

## Priser

Genereringar debiteras i krediter. Kostnaden beror på modellen, parametrarna du väljer, till exempel
upplösning och längd, samt inmatningarna du tillhandahåller. En generering kostar lika mycket via API:t som
den gör i ElevenLabs-appen, där kostnaden visas innan du skickar in den. Se
[Image & Video i playground](/docs/sv/eleven-creative/playground/image-video) för hur kostnaden för
en viss kombination av modell och inställningar visas.

## Lista dina genereringar

Varje slutpunkt listar genereringarna som skapats genom den, med de senaste först. Resultaten är begränsade till din
arbetsyta och detta API, så genereringar som skapats i ElevenLabs-appen visas inte.

```python
page = elevenlabs.flows.image.list(page_size=20, status="completed")

for item in page.generations:
    print(item.id, item.content_url)

while page.has_more:
    page = elevenlabs.flows.image.list(page_size=20, status="completed", cursor=page.next_cursor)
    for item in page.generations:
        print(item.id, item.content_url)
```

```typescript
let page = await elevenlabs.flows.image.list({ pageSize: 20, status: "completed" });

for (const item of page.generations) {
  console.log(item.id, item.contentUrl);
}

while (page.hasMore) {
  page = await elevenlabs.flows.image.list({
    pageSize: 20,
    status: "completed",
    cursor: page.nextCursor,
  });
  for (const item of page.generations) {
    console.log(item.id, item.contentUrl);
  }
}
```

`page_size` accepterar 1 till 100 och har standardvärdet 30. Skicka `status` för att bara returnera genereringar i ett
livscykeltillstånd och `model_id` för att bara returnera genereringar från en enskild modell. Behandla `next_cursor` som
ogenomskinlig: skicka tillbaka exakt värde och sluta när `has_more` är `false`.

## Tillgängliga modeller

API:et exponerar en delmängd av modellerna som finns i ElevenLabs-appen. Varje modell accepterar bara de
parametrar som anges för den – om du skickar ett fält som stöds av en annan modell får du ett valideringsfel.

> **Warning**
>
> ByteDance-modeller är inaktiverade som standard och kräver uttryckligt godkännande innan de kan användas. Tills åtkomst har
> beviljats avvisas en begäran som anger någon av dem med felet `model_access_denied`. Enterprise-
> kunder kan kontakta supporten för att begära åtkomst.

### Bildmodeller

| `model_id`                    | Referensbilder              | Utdatainställningar                                                        |
| ----------------------------- | --------------------------- | -------------------------------------------------------------------------- |
| `gpt-image-1`                 | Upp till 5, plus en `mask`  | `aspect_ratio` (1:1, 3:2, 2:3), `quality`, `background`                    |
| `gpt-image-1.5`               | Upp till 5, plus en `mask`  | `aspect_ratio` (1:1, 3:2, 2:3), `quality`, `background`                    |
| `gpt-image-2`                 | Upp till 10, plus en `mask` | 15 bildförhållanden, `resolution` (1K, 2K, 4K), `quality`                  |
| `gpt-image-2.5-sunburst`      | Upp till 10, plus en `mask` | 15 bildförhållanden, `resolution` (1K, 2K, 4K), `quality` (upp till `max`) |
| `gpt-image-2.5-flare`         | Upp till 10, plus en `mask` | 15 bildförhållanden, `resolution` (1K, 2K, 4K), `quality` (upp till `max`) |
| `gemini-2.5-flash-image`      | Upp till 5                  | `aspect_ratio`                                                             |
| `gemini-3-pro-image`          | Upp till 10                 | `aspect_ratio`, `resolution` (1K, 2K, 4K)                                  |
| `gemini-3.1-flash-image`      | Upp till 14                 | `aspect_ratio` (inklusive 1:4, 4:1, 1:8, 8:1), `resolution` (512 till 4K)  |
| `gemini-3.1-flash-lite-image` | Upp till 14                 | `aspect_ratio`, `resolution` (1K)                                          |
| `bytedance-seedream-5-lite`   | Upp till 10                 | `aspect_ratio`, `resolution` (2K, 3K), `seed`                              |
| `bytedance-seedream-5-pro`    | Upp till 10                 | `aspect_ratio`, `resolution` (1K, 2K), `seed`                              |

GPT Image 2.5-modellerna accepterar `quality`-värdena `low`, `medium`, `high`, `xhigh` och `max`, och
använder `high` som standard. GPT Image 2 går bara till `high` och använder `medium` som standard.

### Videomodeller

| `model_id`                   | Medieindata                                                                | Utdatainställningar                                                                                      |
| ---------------------------- | -------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
| `veo-3.1-generate-001`       | `start_frame`, `end_frame`, upp till 3 `images` med en `role`              | `duration_secs` (4, 6, 8), `aspect_ratio` (16:9, 9:16), `resolution` (720p, 1080p, 4K), `generate_audio` |
| `veo-3.1-fast-generate-001`  | `start_frame`, `end_frame`, upp till 3 `images` med en `role`              | `duration_secs` (4, 6, 8), `aspect_ratio` (16:9, 9:16), `resolution` (720p, 1080p, 4K), `generate_audio` |
| `bytedance-seedance-v2`      | `start_frame`, `end_frame`, upp till 9 `images`, 3 `videos`, 3 `audios`    | `duration_secs` (4 till 15), 7 bildförhållanden, `resolution` (480p till 4k), `generate_audio`           |
| `bytedance-seedance-v2-fast` | `start_frame`, `end_frame`, upp till 9 `images`, 3 `videos`, 3 `audios`    | `duration_secs` (4 till 15), 7 bildförhållanden, `resolution` (480p, 720p), `generate_audio`             |
| `bytedance-seedance-v2-mini` | `start_frame`, `end_frame`, upp till 9 `images`, 3 `videos`, 3 `audios`    | `duration_secs` (4 till 15), 7 bildförhållanden, `resolution` (480p, 720p), `generate_audio`             |
| `bytedance-seedance-v2.5`    | `start_frame`, `end_frame`, upp till 30 `images`, 10 `videos`, 10 `audios` | `duration_secs` (4 till 30), 7 bildförhållanden, `resolution` (480p, 720p), `generate_audio`             |
| `creatify-aurora`            | `image` och `audio`, båda krävs                                            | `resolution` (480p, 720p), `guidance_scale`, `audio_guidance_scale`                                      |

Information om modellfunktioner, tillgänglighet och priser finns i
[översikten över Bild och video](/docs/sv/overview/capabilities/image-video).

## Nästa steg

#### [Referenser och resurser](/docs/sv/eleven-api/guides/how-to/image-and-video/references)

Styr en generering med en tidigare generering, en uppladdad resurs eller integrerade medier.

#### [Webhooks](/docs/sv/eleven-api/guides/how-to/image-and-video/webhooks)

Ta emot resultatet av en generering i stället för att polla efter det.

#### [API-referens](/docs/sv/api-reference/flows/image/create)

Utforska slutpunkterna för bilder, videor och resurser.