Grok Video API 接入文档

Authorization: Bearer <YOUR_API_KEY>

curl -X GET "https://img.gpt88.cc/v1/models" \
  -H "Authorization: Bearer <YOUR_API_KEY>"

curl -X POST "https://img.gpt88.cc/v1/videos/generations" \
  -H "Authorization: Bearer <YOUR_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-image-video",
    "prompt": "A cinematic shot of a red sports car driving through rainy neon streets at night",
    "seconds": 6,
    "aspect_ratio": "16:9",
    "resolution": "720p"
  }'

curl -X POST "https://img.gpt88.cc/v1/videos/generations" \
  -H "Authorization: Bearer <YOUR_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-image-video",
    "prompt": "Animate the product with a slow rotating camera, soft studio light, premium commercial style",
    "seconds": 6,
    "aspect_ratio": "9:16",
    "resolution": "720p",
    "image_urls": [
      "https://example.com/product.png"
    ]
  }'

{
  "model": "grok-image-video",
  "prompt": "Animate the product with a slow rotating camera",
  "seconds": 6,
  "aspect_ratio": "9:16",
  "resolution": "720p",
  "input_reference": {
    "image_url": "https://example.com/product.png"
  }
}

curl -X POST "https://img.gpt88.cc/v1/videos/generations" \
  -H "Authorization: Bearer <YOUR_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-image-video",
    "prompt": "Create a smooth product showcase video using these references, luxury lighting, clean background",
    "seconds": 10,
    "aspect_ratio": "16:9",
    "resolution": "720p",
    "image_urls": [
      "https://example.com/ref-1.png",
      "https://example.com/ref-2.png"
    ]
  }'

curl -X POST "https://img.gpt88.cc/v1/videos/generations" \
  -H "Authorization: Bearer <YOUR_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-video-1.5",
    "prompt": "Use the reference image as the main subject and create a smooth cinematic motion",
    "seconds": 4,
    "aspect_ratio": "16:9",
    "resolution": "480p",
    "image_urls": [
      "https://example.com/reference.png"
    ]
  }'

{
  "id": "task_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
  "task_id": "task_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
  "object": "video",
  "model": "grok-image-video",
  "status": "queued",
  "progress": 0,
  "created_at": 1780000000
}

curl --fail-with-body --max-redirs 0 \
  "https://img.gpt88.cc/v1/videos/video_gpt88_v1_dmlkZW9fYmY2OTEwODkwYmEwNGRjNThiODI4NWMzMTMzN2QwMTI" \
  -H "Authorization: Bearer $GPT88_API_KEY"

{
  "code": "success",
  "message": "",
  "data": {
    "task_id": "task_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "status": "IN_PROGRESS",
    "progress": "30%",
    "result_url": "",
    "fail_reason": ""
  }
}

{
  "code": "success",
  "message": "",
  "data": {
    "task_id": "task_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "status": "SUCCESS",
    "progress": "100%",
    "result_url": "https://example.com/generated-video.mp4",
    "fail_reason": ""
  }
}

{
  "code": "success",
  "message": "",
  "data": {
    "task_id": "task_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "status": "FAILURE",
    "progress": "100%",
    "result_url": "",
    "fail_reason": "Image URL could not be fetched: Fetching image failed with HTTP status 400 Bad Request."
  }
}

{
  "id": "video_gpt88_v1_dmlkZW9fYmY2OTEwODkwYmEwNGRjNThiODI4NWMzMTMzN2QwMTI",
  "model": "grok-imagine-video",
  "object": "video",
  "progress": 100,
  "request_id": "video_bf6910890ba04dc58b8285c31337d012",
  "status": "completed",
  "url": "/v1/videos/video_bf6910890ba04dc58b8285c31337d012/content",
  "video": {
    "duration": 6,
    "task_id": "video_bf6910890ba04dc58b8285c31337d012",
    "url": "/v1/videos/video_bf6910890ba04dc58b8285c31337d012/content"
  },
  "video_url": "/v1/videos/video_bf6910890ba04dc58b8285c31337d012/content"
}

curl --fail-with-body --max-redirs 0 \
  "https://img.gpt88.cc/v1/videos/video_gpt88_v1_dmlkZW9fYmY2OTEwODkwYmEwNGRjNThiODI4NWMzMTMzN2QwMTI/content" \
  -H "Authorization: Bearer $GPT88_API_KEY" \
  -o generated-video.mp4

import os
from pathlib import Path
import requests

base_url = "https://img.gpt88.cc"
video_id = "video_gpt88_v1_dmlkZW9fYmY2OTEwODkwYmEwNGRjNThiODI4NWMzMTMzN2QwMTI"
headers = {"Authorization": f"Bearer {os.environ['GPT88_API_KEY']}"}

status = requests.get(
    f"{base_url}/v1/videos/{video_id}",
    headers=headers,
    timeout=30,
)
status.raise_for_status()
payload = status.json()

if payload.get("status") != "completed":
    raise RuntimeError(f"video is not ready: {payload}")

content = requests.get(
    f"{base_url}/v1/videos/{video_id}/content",
    headers=headers,
    timeout=120,
)
content.raise_for_status()
Path("generated-video.mp4").write_bytes(content.content)
print("saved generated-video.mp4")

import { writeFile } from "node:fs/promises";

const baseUrl = "https://img.gpt88.cc";
const videoId = "video_gpt88_v1_dmlkZW9fYmY2OTEwODkwYmEwNGRjNThiODI4NWMzMTMzN2QwMTI";
const headers = { Authorization: "Bearer " + process.env.GPT88_API_KEY };

const statusResponse = await fetch(baseUrl + "/v1/videos/" + videoId, { headers });
const status = await statusResponse.json();
if (!statusResponse.ok || status.status !== "completed") {
  throw new Error("video is not ready: " + JSON.stringify(status));
}

const contentResponse = await fetch(baseUrl + "/v1/videos/" + videoId + "/content", { headers });
if (!contentResponse.ok) throw new Error("download failed: " + contentResponse.status);
await writeFile("generated-video.mp4", Buffer.from(await contentResponse.arrayBuffer()));
console.log("saved generated-video.mp4");

const BASE_URL = 'https://img.gpt88.cc'
const API_KEY = process.env.GPT88_API_KEY

function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms))
}

function validateVideoRequest({ model, imageUrls }) {
  if (model === 'grok-video-1.5' && imageUrls.length !== 1) {
    throw new Error('grok-video-1.5 only supports exactly one reference image.')
  }

  if (model === 'grok-image-video' && imageUrls.length > 7) {
    throw new Error('grok-image-video supports at most 7 reference images.')
  }
}

async function createVideo({
  model = 'grok-image-video',
  prompt,
  seconds = 4,
  aspectRatio = '16:9',
  resolution = '720p',
  imageUrls = [],
}) {
  validateVideoRequest({ model, imageUrls })

  const body = {
    model,
    prompt,
    seconds,
    aspect_ratio: aspectRatio,
    resolution,
  }

  if (imageUrls.length > 0) {
    body.image_urls = imageUrls
    if (imageUrls.length >= 2 && Number(body.seconds) > 10) {
      body.seconds = 10
    }
  }

  const createResponse = await fetch(\`\${BASE_URL}/v1/videos/generations\`, {
    method: 'POST',
    headers: {
      Authorization: \`Bearer \${API_KEY}\`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(body),
  })

  const created = await createResponse.json()
  if (!createResponse.ok) {
    throw new Error(\`Video request failed: \${JSON.stringify(created)}\`)
  }

  const videoId = created.id || created.request_id || created.task_id
  if (!videoId) {
    throw new Error(\`No video id returned: \${JSON.stringify(created)}\`)
  }

  for (let i = 0; i < 60; i += 1) {
    await sleep(5000)

    const pollResponse = await fetch(\`\${BASE_URL}/v1/videos/\${encodeURIComponent(videoId)}\`, {
      headers: {
        Authorization: \`Bearer \${API_KEY}\`,
      },
    })

    const result = await pollResponse.json()
    if (!pollResponse.ok) {
      throw new Error(\`Video poll failed: \${JSON.stringify(result)}\`)
    }

    const status = String(result.status || result.data?.status || '').toLowerCase()
    const completed = ['completed', 'complete', 'done', 'success', 'succeeded'].includes(status)
    if (completed) {
      const contentResponse = await fetch(\`\${BASE_URL}/v1/videos/\${encodeURIComponent(videoId)}/content\`, {
        headers: {
          Authorization: \`Bearer \${API_KEY}\`,
        },
      })
      if (!contentResponse.ok) {
        throw new Error(\`Video download failed: \${contentResponse.status}\`)
      }

      const file = Buffer.from(await contentResponse.arrayBuffer())
      const { writeFile } = await import('node:fs/promises')
      await writeFile(\`generated-\${videoId}.mp4\`, file)
      return {
        video_id: videoId,
        file: \`generated-\${videoId}.mp4\`,
        raw_response: result,
      }
    }

    if (['failed', 'failure', 'cancelled', 'canceled', 'expired'].includes(status)) {
      throw new Error(\`Video generation failed: \${result.error?.message || result.fail_reason || JSON.stringify(result)}\`)
    }
  }

  throw new Error(\`Video generation timeout: \${videoId}\`)
}