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

# Grok Videos Generation API Integrationsbeskrivning

> Grok API guide - Ace Data Cloud

Denna artikel kommer att introducera integrationsbeskrivningen för Grok Videos Generation API, som kan generera Grok Imagine (xAI) videor genom att mata in textpromptar, bilder och valfria referensbilder.

## Ansökningsprocess

För att använda Grok Videos Generation API, börja med att gå till [Ace Data Cloud-konsolen](https://platform.acedata.cloud/console/applications) för att få din API-token, som du ska spara.

![](https://cdn.acedata.cloud/dvc3cg.jpg)

Om du inte har loggat in eller registrerat dig kommer du automatiskt att omdirigeras till inloggningssidan där du uppmanas att registrera dig och logga in, och efter att ha slutfört detta kommer du automatiskt att återvända till den aktuella sidan.

**En API-token kan användas för att anropa alla tjänster på plattformen, det behövs ingen separat ansökan för varje tjänst.** Första ansökan ger en gratis kvot för att prova; när kvoten är slut kan du ladda på allmän balans i [konsolen](https://platform.acedata.cloud/console/coin).

> 📘 Fullständig dokumentation: [Grok Videos Generation API →](https://platform.acedata.cloud/documents/grok-videos)

## Modellbeskrivning

Denna API väljer upstream-endpoint genom suffixet på modellnamnet: `:reverse` går till snabb/standard-endpoint (billigare), `:official` går till officiell endpoint (högre bildkvalitet, debiteras per utgångssekund). Totalt stöds fyra modeller:

* `grok-imagine-video-1.5-fast:reverse` (standard): Stöder text-till-video (endast ange `prompt`) och bild-till-video (ange `image_url`), längd 6–30 sekunder, debiteras baserat på längd, billigast.
* `grok-imagine-video:reverse`: Stöder text-till-video och bild-till-video, längd 1–15 sekunder, debiteras per utgångssekund.
* `grok-imagine-video:official`: Officiell endpoint, stöder text-till-video och bild-till-video, längd 1–15 sekunder, debiteras per utgångssekund, högre bildkvalitet.
* `grok-imagine-video-1.5:official`: Officiell endpoint, **stödjer endast bild-till-video**, **måste** ange `image_url`, längd 1–15 sekunder, stöder upp till `1080p`, debiteras per utgångssekund.

## Grundläggande användning

Först, förstå den grundläggande användningen, ange textprompt `prompt`, modell `model` och andra parametrar för att generera motsvarande video.

Här kan vi se att vi har ställt in Request Headers, inklusive:

* `accept`: Vilket format av svarresultat du vill ta emot, här anges `application/json`, det vill säga JSON-format.
* `authorization`: Nyckeln för att anropa API:et, efter ansökan kan du direkt välja från rullgardinsmenyn.

Dessutom har vi ställt in Request Body, inklusive:

* `prompt`: Textprompt som beskriver innehållet du vill generera i videon. Obligatoriskt vid text-till-video; valfritt när `image_url` anges.
* `model`: Modellen för att generera videon, kan vara `grok-imagine-video-1.5-fast:reverse` (standard), `grok-imagine-video:reverse`, `grok-imagine-video:official` eller `grok-imagine-video-1.5:official`.
* `image_url`: Länk till inmatningsbilden för bild-till-video. Obligatoriskt när `model` är `grok-imagine-video-1.5:official`.
* `reference_image_urls`: Valfri array av referensbildlänkar för att vägleda videons stil eller innehåll.
* `aspect_ratio`: Bredd-höjd-förhållande för den genererade videon, kan vara `1:1` / `16:9` / `9:16` / `4:3` / `3:4` / `3:2` / `2:3`.
* `resolution`: Utgångsupplösning, kan vara `480p` (standard), `720p` eller `1080p`.
* `duration`: Längden på den genererade videon (sekunder). `grok-imagine-video-1.5-fast:reverse` har ett intervall på 6–30, övriga modeller har ett intervall på 1–15, standard 6. Rekommenderas att använda 6 sekunder eller 10 sekunder, dessa två standardlängder är relativt stabila.
* `callback_url`: Asynkron återkopplingsadress, när den är inställd kommer API:et omedelbart att returnera `task_id`, och när uppgiften är klar kommer resultatet att POST:as till den adressen.
* `async`: Valfritt, sätt till `true` så returnerar gränssnittet omedelbart `task_id`, utan att behöva ange `callback_url`, och sedan kan du använda motsvarande uppgiftsfrågegränssnitt för att pollera och hämta resultatet.

Klicka på "Try" knappen för att testa, resultatet du får liknar följande:

```json theme={null}
{
  "success": true,
  "task_id": "b8976e18-32dc-4718-9ed8-1ea090fcb6ea",
  "trace_id": "fb751e1e-4705-49ea-9fd4-5024b7865ea2",
  "data": [
    {
      "id": "grok-imagine-video-1.5-fast:reverse:41eb9a5f-3b2d-4d1e-9f5a-6c2f1a0b9e77",
      "video_url": "https://cdn.acedata.cloud/c8cbf53aa0.mp4",
      "state": "succeeded"
    }
  ]
}
```

Det returnerade resultatet har flera fält, som beskrivs nedan:

* `success`: Om denna video-genereringsförfrågan var framgångsrik.
* `task_id`: ID för denna video-genereringsuppgift.
* `trace_id`: Spårnings-ID för denna förfrågan, används för att felsöka problem.
* `data`: Lista över genererade videoresultat.
  * `id`: Unik identifierare för den genererade videon.
  * `video_url`: Länkadress till den genererade videon.
  * `state`: Status för video-genereringsuppgiften, kan vara `pending` / `succeeded` / `failed`.

Vi behöver bara hämta den genererade videon via `video_url` länken i `data` resultatet.

Motsvarande CURL-kod ser ut så här:

```shell theme={null}
curl -X POST 'https://api.acedata.cloud/grok/videos' \
-H 'authorization: Bearer ${bearer_token}' \
-H 'accept: application/json' \
-H 'content-type: application/json' \
-d '{
  "prompt": "A cinematic shot of a kitten chasing a butterfly in a sunlit garden",
  "model": "grok-imagine-video-1.5-fast:reverse",
  "resolution": "480p",
  "duration": 6
}'
```

Motsvarande Python-kod ser ut så här:

```python theme={null}
import requests

url = "https://api.acedata.cloud/grok/videos"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "prompt": "A cinematic shot of a kitten chasing a butterfly in a sunlit garden",
    "model": "grok-imagine-video-1.5-fast:reverse",
    "resolution": "480p",
    "duration": 6
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)
```

## Bild-till-video

Om du vill generera en video baserat på en inmatningsbild kan du ange `image_url`. När du använder `grok-imagine-video-1.5:official` måste detta fält anges:

```json theme={null}
{
  "prompt": "The character slowly turns around and smiles at the camera",
  "model": "grok-imagine-video-1.5:official",
  "image_url": "https://cdn.acedata.cloud/5hmkdg.jpg",
  "resolution": "720p",
  "duration": 6
}
```

## Referensbilder för vägledning

Om du vill använda en eller flera referensbilder för att vägleda videons stil eller innehåll kan du ange en array av bildlänkar i `reference_image_urls`:

```json theme={null}
{
  "prompt": "A character dancing in the same art style",
  "model": "grok-imagine-video-1.5-fast:reverse",
  "reference_image_urls": [
    "https://cdn.acedata.cloud/vunnjf.png"
  ]
}
```

## Asynkron återkoppling

Videogenerering kräver viss behandlingstid. Om du inte vill hålla en lång anslutning och vänta kan du ange `callback_url`, då kommer API:et omedelbart att returnera `task_id`, och när uppgiften är klar kommer det slutliga resultatet att POST:as till den adressen:

```json theme={null}
{
  "prompt": "En filmisk bild av en kattunge som jagar en fjäril i en solbelyst trädgård",
  "model": "grok-imagine-video-1.5-fast:reverse",
  "duration": 6,
  "callback_url": "https://your-domain.com/callback/grok"
}
```

Det omedelbara svaret ser ut som följer:

```json theme={null}
{
  "task_id": "b8976e18-32dc-4718-9ed8-1ea090fcb6ea"
}
```

## Fråga om uppgiftsresultat

Om du har använt asynkron callback eller vill aktivt fråga om uppgiftens status kan du använda [Grok Tasks API](https://platform.acedata.cloud/documents/grok-tasks) (`POST https://api.acedata.cloud/grok/tasks`) för att fråga om den senaste statusen och resultatet baserat på `task_id`.

## Avgiftsinformation

Denna tjänsts avgiftsmodell bestäms av `model`:

* `grok-imagine-video-1.5-fast:reverse`: avgift baserat på längd, oberoende av upplösning — `6–10` sekunder, `11–20` sekunder, `21–30` sekunder motsvarar olika prisklasser.
* `grok-imagine-video:reverse`: avgift baserat på "utgångssekunder", totalpris = enhetspris × `duration`.
* `grok-imagine-video:official` och `grok-imagine-video-1.5:official`: officiella slutpunkter, avgift baserat på "utgångssekunder", ju högre upplösning desto högre enhetspris; officiella modeller debiteras även om innehållsgranskningen misslyckas.

Specifika enhetspriser anges på prissidan. Misslyckade förfrågningar debiteras inte och påverkar inte den kostnadsfria kvoten.

## Felhantering

När en förfrågan uppstår problem kommer API:et att returnera motsvarande felkod och beskrivning, vanliga är följande:

* `400`: Förfrågningsparametrar är felaktiga, till exempel saknas `prompt` för videon, eller `grok-imagine-video-1.5:official` saknar `image_url`, eller `duration` överskrider gränsen (för `grok-imagine-video-1.5-fast:reverse` är det 6–30, för övriga modeller 1–15).
* `401`: Autentisering misslyckades, token är ogiltig eller matchar inte API:et.
* `403`: Otillräcklig balans, eller prompten träffar innehållsgranskningen och nekas.
* `429`: För många förfrågningar, vänligen försök igen senare.
* `500`: Videogenerering misslyckades eller tjänsten är i ett felaktigt tillstånd.


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