GLX Studio API

The GLX Studio API enables third-party applications to programmatically generate professional videos through our AI-powered storybuilder pipeline. Upload knowledge documents once, define reusable prompt templates, and trigger video generation at scale.

Base URL

https://api.glxstudio.com

Workflow

Provide Document URLs

→

Create Knowledge Base

→

Choose Template

→

Submit Job

→

Receive Callback

Core Concepts

Knowledge Base — A persistent collection of documents (PDFs, PPTX, etc.) backed by an AI vector store. Provide URLs to your files — GLX downloads and indexes them server-side. Create once, reference across many video generation calls.

Prompt Template — A company-owned, reusable prompt with {{variable}} slots, default language/voice settings, and optional branding config. Managed via the Developer Dashboard.

Storybuilder Job — A single video generation request combining a knowledge base + template + variables. Runs asynchronously and delivers the result via callback.

Authentication

All API requests require a Bearer token in the Authorization header. API keys are managed from the Developer Dashboard.

HEADER Authorization: Bearer {api_key}

Keys are scoped to a single company. All resources created with a key belong to that company.

Rate Limits

API requests are rate-limited per company. Current limits:

Endpoint	Limit	Window
POST /api/storybuilder	100 requests	per hour
POST /api/knowledge	50 requests	per hour
GET endpoints	500 requests	per hour

Rate limit headers are included in every response: X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset.

Error Handling

The API uses standard HTTP status codes. Errors return a JSON body with error and code fields.

Code	Meaning	Example
400	Bad Request	Missing required variable, invalid template ID
401	Unauthorized	Missing or invalid Bearer token
404	Not Found	Knowledge base or job ID doesn't exist
422	Unprocessable	Template requires variables not provided
429	Rate Limited	Too many requests
500	Server Error	Internal pipeline failure

{
  "error": "Missing required variable: company_name",
  "code": "MISSING_VARIABLE"
}

Create Knowledge Base

POST /api/knowledge

Create a new knowledge base by providing URLs to your documents. GLX Studio will download and process the files server-side, indexing them for AI retrieval. No file uploads needed — just pass accessible URLs.

Request Body

Field	Type	Description
name REQUIRED	string	Human-readable name for this knowledge base
files REQUIRED	array	Array of file objects, each with a `url` field. Supported formats: PDF, PPTX, CSV, DOCX, JSON, TXT, XLSX. Max 15MB per file.
files[].url REQUIRED	string	Publicly accessible URL to the document file
files[].name	string	Optional display name. If omitted, derived from URL filename.

Response

201 Created

{
  "knowledgeBaseId": 3847,
  "name": "Acme Corp Pitch Deck",
  "status": "processing",
  "files": [
    { "name": "pitchdeck.pdf", "url": "https://example.com/docs/pitchdeck.pdf", "status": "downloading" }
  ]
}

Files are downloaded and indexed asynchronously. Status transitions: downloading → indexing → ready. Poll the knowledge base to check when processing is complete.

Add Files to Knowledge Base

POST /api/knowledge/{id}

Add additional files to an existing knowledge base by providing URLs. New files are downloaded and indexed alongside existing ones.

Response

200 OK

{
  "knowledgeBaseId": 3847,
  "status": "processing",
  "files": [
    { "name": "pitchdeck.pdf", "status": "ready" },
    { "name": "appendix.pdf", "status": "downloading" }
  ]
}

List Knowledge Bases

GET /api/knowledge

Retrieve all knowledge bases for your company.

Get Knowledge Base

GET /api/knowledge/{id}

Get details for a specific knowledge base including file list and status.

Delete Knowledge Base

DELETE /api/knowledge/{id}

Permanently delete a knowledge base and its associated vector store. This cannot be undone.

List Templates

GET /api/templates

List all active templates for your company. Templates are created via the Developer Dashboard and are read-only via the API.

200 OK

{
  "templates": [
    {
      "templateId": 92,
      "name": "30-Second Elevator Pitch",
      "variables": {
        "company_name": { "required": true },
        "tone": { "required": false, "default": "professional and energetic" }
      },
      "defaults": { "language": "en", "mediaSourcePosition": 0 }
    }
  ]
}

Get Template Details

GET /api/templates/{id}

Get full details of a specific template including prompt text, variable schema, and default configuration.

Create Storybuilder Job

POST /api/storybuilder

Submit a video generation job. The job runs asynchronously through the full AI pipeline (creative brief, visual planning, TTS, media search, rendering). Results are delivered via callback URL.

Request Body

Field	Type	Description
knowledgeBaseId REQUIRED	integer	ID of the knowledge base to use
templateId REQUIRED	integer	ID of the prompt template
variables REQUIRED	object	Key-value pairs for template variables
callbackUrl REQUIRED	string	URL to receive the result via POST
language	string	ISO 639-1 code (overrides template default)
voiceId	string	ElevenLabs voice ID (overrides language default)

Response

202 Accepted

{
  "jobId": 5501,
  "status": "processing"
}

Get Job Status

GET /api/storybuilder/{id}

Poll the status of a video generation job. The callback URL is the primary delivery mechanism; use this endpoint for manual checks.

{
  "jobId": 5501,
  "status": "processing",
  "templateId": 92,
  "knowledgeBaseId": 3847,
  "createdAt": "2026-02-11T14:30:00Z"
}

Callback Payload

When a job completes (or fails), GLX Studio sends a POST request to your callbackUrl with the result. Callbacks are retried 3 times with exponential backoff (5s, 30s, 120s).

Success Payload

{
  "jobId": 5501,
  "status": "completed",
  "videoUrl": "https://cdn.glxstudio.com/videos/...",
  "thumbnailUrl": "https://cdn.glxstudio.com/thumbs/...",
  "duration": 32
}

Failure Payload

{
  "jobId": 5501,
  "status": "failed",
  "error": "Creative brief generation failed: insufficient content"
}

Quick Start Guide

Get your first AI-generated video in under 5 minutes:

1. Get an API key from the Developer Dashboard

2. Provide document URLs to create a knowledge base

3. Browse available templates or create your own

4. Submit a storybuilder job with your knowledge base + template + variables

5. Receive the completed video via callback URL

Average processing time is 2-5 minutes per video depending on duration and complexity.

Webhook Integration

Each storybuilder job requires a callbackUrl. When the job completes, GLX Studio sends a POST with the result payload. Your endpoint should return a 2xx response within 10 seconds.

If the callback fails, it is retried 3 times with exponential backoff: 5 seconds, 30 seconds, then 120 seconds. After 3 failures, the callback status is marked as failed and can be viewed in the Developer Dashboard activity log.

You can also poll the job status endpoint as a fallback: GET /api/storybuilder/{jobId}

curl

Python

JavaScript

Authentication Header

curl https://api.glxstudio.com/api/knowledge \
  -H "Authorization: Bearer sk_live_a7f3..."

import requests

headers = {"Authorization": "Bearer sk_live_a7f3..."}
response = requests.get(
    "https://api.glxstudio.com/api/knowledge",
    headers=headers
)

const response = await fetch("https://api.glxstudio.com/api/knowledge", {
  headers: { "Authorization": "Bearer sk_live_a7f3..." }
});

req, _ := http.NewRequest("GET", "https://api.glxstudio.com/api/knowledge", nil)
req.Header.Set("Authorization", "Bearer sk_live_a7f3...")
resp, _ := http.DefaultClient.Do(req)

Create Knowledge Base

curl -X POST https://api.glxstudio.com/api/knowledge \
  -H "Authorization: Bearer sk_live_a7f3..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Acme Corp Pitch Deck",
    "files": [
      {"url": "https://example.com/docs/pitchdeck.pdf"}
    ]
  }'

response = requests.post(
    "https://api.glxstudio.com/api/knowledge",
    headers={"Authorization": "Bearer sk_live_a7f3..."},
    json={
        "name": "Acme Corp Pitch Deck",
        "files": [
            {"url": "https://example.com/docs/pitchdeck.pdf"}
        ]
    }
)

const response = await fetch("https://api.glxstudio.com/api/knowledge", {
  method: "POST",
  headers: {
    "Authorization": "Bearer sk_live_a7f3...",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    name: "Acme Corp Pitch Deck",
    files: [
      { url: "https://example.com/docs/pitchdeck.pdf" }
    ]
  })
});

payload := map[string]interface{}{
    "name": "Acme Corp Pitch Deck",
    "files": []map[string]string{
        {"url": "https://example.com/docs/pitchdeck.pdf"},
    },
}
body, _ := json.Marshal(payload)

req, _ := http.NewRequest("POST", "https://api.glxstudio.com/api/knowledge", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer sk_live_a7f3...")
req.Header.Set("Content-Type", "application/json")

Create Storybuilder Job

curl -X POST https://api.glxstudio.com/api/storybuilder \
  -H "Authorization: Bearer sk_live_a7f3..." \
  -H "Content-Type: application/json" \
  -d '{
    "knowledgeBaseId": 3847,
    "templateId": 92,
    "variables": {
      "company_name": "Acme Corp"
    },
    "callbackUrl": "https://your-app.com/hooks/video-ready"
  }'

import requests

response = requests.post(
    "https://api.glxstudio.com/api/storybuilder",
    headers={"Authorization": "Bearer sk_live_a7f3..."},
    json={
        "knowledgeBaseId": 3847,
        "templateId": 92,
        "variables": {"company_name": "Acme Corp"},
        "callbackUrl": "https://your-app.com/hooks/video-ready"
    }
)
print(response.json())  # {"jobId": 5501, "status": "processing"}

const response = await fetch("https://api.glxstudio.com/api/storybuilder", {
  method: "POST",
  headers: {
    "Authorization": "Bearer sk_live_a7f3...",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    knowledgeBaseId: 3847,
    templateId: 92,
    variables: { company_name: "Acme Corp" },
    callbackUrl: "https://your-app.com/hooks/video-ready"
  })
});

const data = await response.json();
console.log(data); // {jobId: 5501, status: "processing"}

payload := map[string]interface{}{
    "knowledgeBaseId": 3847,
    "templateId":      92,
    "variables":       map[string]string{"company_name": "Acme Corp"},
    "callbackUrl":    "https://your-app.com/hooks/video-ready",
}
body, _ := json.Marshal(payload)

req, _ := http.NewRequest("POST", "https://api.glxstudio.com/api/storybuilder", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer sk_live_a7f3...")
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)

Poll Job Status

curl https://api.glxstudio.com/api/storybuilder/5501 \
  -H "Authorization: Bearer sk_live_a7f3..."

response = requests.get(
    "https://api.glxstudio.com/api/storybuilder/5501",
    headers={"Authorization": "Bearer sk_live_a7f3..."}
)
print(response.json()["status"])  # "processing" or "completed"

const res = await fetch("https://api.glxstudio.com/api/storybuilder/5501", {
  headers: { "Authorization": "Bearer sk_live_a7f3..." }
});
const { status } = await res.json();

req, _ := http.NewRequest("GET", "https://api.glxstudio.com/api/storybuilder/5501", nil)
req.Header.Set("Authorization", "Bearer sk_live_a7f3...")
resp, _ := http.DefaultClient.Do(req)

Handle Callback (Your Server)

# Callback is a POST from GLX to your server.
# Example incoming payload:
{
  "jobId": 5501,
  "status": "completed",
  "videoUrl": "https://cdn.glxstudio.com/...",
  "duration": 32
}

# Flask example
from flask import Flask, request

app = Flask(__name__)

@app.route("/hooks/video-ready", methods=["POST"])
def handle_callback():
    data = request.json
    if data["status"] == "completed":
        video_url = data["videoUrl"]
        # Process the completed video...
    else:
        error = data["error"]
        # Handle failure...
    return "", 200

// Express example
app.post("/hooks/video-ready", (req, res) => {
  const { jobId, status, videoUrl, error } = req.body;

  if (status === "completed") {
    console.log(`Video ready: ${videoUrl}`);
    // Process the completed video...
  } else {
    console.error(`Job ${jobId} failed: ${error}`);
  }

  res.sendStatus(200);
});

func handleCallback(w http.ResponseWriter, r *http.Request) {
    var payload struct {
        JobID     int    `json:"jobId"`
        Status    string `json:"status"`
        VideoURL  string `json:"videoUrl"`
        Error     string `json:"error"`
    }
    json.NewDecoder(r.Body).Decode(&payload)

    if payload.Status == "completed" {
        log.Printf("Video ready: %s", payload.VideoURL)
    }
    w.WriteHeader(http.StatusOK)
}