VoidAI

https://docs.voidai.app/api-reference/
Admin
VoidAI provides a unified API endpoint to access AI models from 15+ providers including GPT, Claude,...
Tokens:27,327
Snippets:179
Trust Score:4.5
Update:5 months ago
Show doc for...
Tokens:
Raw
### Download Spritesheet Example

Source: https://docs.voidai.app/api-reference/video/download

Example of how to download the spritesheet using Python.

```Python
import requests

video_id = "vid_abc123"

response = requests.get(
    f"https://api.voidai.app/v1/videos/{video_id}/content",
    headers={"Authorization": "Bearer sk-voidai-your_key_here"},
    params={"variant": "spritesheet"}
)

with open("spritesheet.jpg", "wb") as f:
    f.write(response.content)
```

--------------------------------

### Download Video Example

Source: https://docs.voidai.app/api-reference/video/download

Example of how to download the video file using Python.

```Python
import requests

video_id = "vid_abc123"

response = requests.get(
    f"https://api.voidai.app/v1/videos/{video_id}/content",
    headers={"Authorization": "Bearer sk-voidai-your_key_here"}
)

with open("output.mp4", "wb") as f:
    f.write(response.content)

print("Video saved as output.mp4")
```

--------------------------------

### Download Thumbnail Example

Source: https://docs.voidai.app/api-reference/video/download

Example of how to download the thumbnail image using Python.

```Python
import requests

video_id = "vid_abc123"

response = requests.get(
    f"https://api.voidai.app/v1/videos/{video_id}/content",
    headers={"Authorization": "Bearer sk-voidai-your_key_here"},
    params={"variant": "thumbnail"}
)

with open("thumbnail.webp", "wb") as f:
    f.write(response.content)
```

--------------------------------

### Similarity Search Example

Source: https://docs.voidai.app/api-reference/embeddings/create

This example demonstrates how to generate embeddings for a list of documents and a query, then calculate cosine similarity to find the most relevant document. Ensure you have `numpy` installed and replace the API key and base URL with your actual credentials.

```python
import numpy as np
from openai import OpenAI

client = OpenAI(
    api_key="sk-voidai-your_key_here",
    base_url="https://api.voidai.app/v1"
)

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# Create embeddings for documents
documents = [
    "Python is a programming language",
    "JavaScript runs in the browser",
    "Machine learning uses neural networks"
]

doc_embeddings = client.embeddings.create(
    model="text-embedding-3-small",
    input=documents
).data

# Search query
query = "How do I code in Python?"
query_embedding = client.embeddings.create(
    model="text-embedding-3-small",
    input=query
).data[0].embedding

# Find most similar document
similarities = [
    cosine_similarity(query_embedding, doc.embedding)
    for doc in doc_embeddings
]

best_match_idx = np.argmax(similarities)
print(f"Best match: {documents[best_match_idx]}")
print(f"Similarity: {similarities[best_match_idx]:.4f}")
```

--------------------------------

### Model Response Example

Source: https://docs.voidai.app/api-reference/models/get

Example JSON response when a model is successfully retrieved.

```json
{
  "id": "gpt-4",
  "object": "model",
  "created": 1687882411,
  "owned_by": "openai"
}
```

--------------------------------

### Pending Video Response Example

Source: https://docs.voidai.app/api-reference/video/get

This is an example of the JSON response when a video generation task is pending.

```JSON
{
  "id": "vid_abc123",
  "status": "pending",
  "prompt": "A serene beach at sunset with gentle waves",
  "model": "sora-2",
  "size": "1920x1080",
  "created_at": 1701691200
}
```

--------------------------------

### Complete Download Workflow Example

Source: https://docs.voidai.app/api-reference/video/download

A comprehensive Python script demonstrating the complete workflow from video creation to downloading all variants.

```Python
import time
import requests

headers = {"Authorization": "Bearer sk-voidai-your_key_here"}
base_url = "https://api.voidai.app/v1/videos"

# 1. Create video
create_response = requests.post(
    base_url,
    headers=headers,
    data={
        "model": "sora-2",
        "prompt": "A timelapse of clouds moving over a mountain",
        "size": "1920x1080",
        "seconds": "10"
    }
)
video_id = create_response.json()["id"]
print(f"Created video: {video_id}")

# 2. Wait for completion
while True:
    status_response = requests.get(f"{base_url}/{video_id}", headers=headers)
    status = status_response.json()["status"]

    if status == "completed":
        print("Video completed!")
        break
    elif status == "failed":
        print(f"Failed: {status_response.json().get('error')}")
        exit(1)

    print(f"Status: {status}")
    time.sleep(15)

# 3. Download all variants
variants = ["video", "thumbnail", "spritesheet"]
extensions = {"video": "mp4", "thumbnail": "webp", "spritesheet": "jpg"}

for variant in variants:
    response = requests.get(
        f"{base_url}/{video_id}/content",
        headers=headers,
        params={"variant": variant}
    )

    filename = f"output.{extensions[variant]}"
    with open(filename, "wb") as f:
        f.write(response.content)

    print(f"Downloaded {variant} as {filename}")
```

--------------------------------

### Python Chat Completion Example

Source: https://docs.voidai.app

Use this snippet to generate text with chat models like GPT-5 and Claude. Ensure you have the 'openai' library installed and replace 'sk-voidai-your_key_here' with your actual API key.

```python
from openai import OpenAI

client = OpenAI(
    api_key="sk-voidai-your_key_here",
    base_url="https://api.voidai.app/v1"
)

response = client.chat.completions.create(
    model="gpt-5.1",
    messages=[
        {"role": "user", "content": "Hello!"}
    ]
)

print(response.choices[0].message.content)

```

--------------------------------

### Completed Video Response Example

Source: https://docs.voidai.app/api-reference/video/get

This is an example of the JSON response when a video generation task has been successfully completed.

```JSON
{
  "id": "vid_abc123",
  "status": "completed",
  "prompt": "A serene beach at sunset with gentle waves",
  "model": "sora-2",
  "size": "1920x1080",
  "duration": 10.0,
  "created_at": 1701691200,
  "completed_at": 1701691500
}
```

--------------------------------

### Eligible Models Response Example

Source: https://docs.voidai.app/api-reference/discounts/eligible-models

This is an example of the JSON response you can expect when querying for eligible models. It lists all models that can receive discounts and those currently discounted.

```json
{
  "models": [
    "gpt-4",
    "gpt-4o",
    "claude-3-5-sonnet",
    "claude-3-opus",
    "gemini-2.0-flash",
    "gemini-1.5-pro",
    "mistral-large"
  ],
  "current_discounted": [
    "claude-3-5-sonnet",
    "gpt-4o"
  ]
}
```

--------------------------------

### TypeScript JSON Mode Example

Source: https://docs.voidai.app/api-reference/chat/completions

Sets up a chat completion request in TypeScript to enforce JSON output. A system prompt guides the model, and the user's request is processed. The resulting JSON string is parsed and logged.

```TypeScript
const response = await client.chat.completions.create({
  model: 'gpt-4',
  messages: [
    { role: 'system', content: 'You are a helpful assistant that responds in JSON.' },
    { role: 'user', content: 'List 3 programming languages with their year of creation' }
  ],
  response_format: { type: 'json_object' }
});

const data = JSON.parse(response.choices[0].message.content);
console.log(data);
```

--------------------------------

### Python JSON Mode Example

Source: https://docs.voidai.app/api-reference/chat/completions

Configures the API request in Python to ensure the response is strictly in JSON format. Includes a system message to guide the assistant and a user prompt, then parses and prints the JSON output.

```Python
response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": "You are a helpful assistant that responds in JSON."},
        {"role": "user", "content": "List 3 programming languages with their year of creation"}
    ],
    response_format={"type": "json_object"}
)

import json
data = json.loads(response.choices[0].message.content)
print(data)
```

--------------------------------

### Failed Video Response Example

Source: https://docs.voidai.app/api-reference/video/get

This is an example of the JSON response when a video generation task has failed.

```JSON
{
  "id": "vid_abc123",
  "status": "failed",
  "prompt": "A serene beach at sunset with gentle waves",
  "model": "sora-2",
  "size": "1920x1080",
  "created_at": 1701691200,
  "error": "Content policy violation detected"
}
```

--------------------------------

### Active Discounts Response Example

Source: https://docs.voidai.app/api-reference/discounts/my-discounts

This is a sample JSON response when active discounts are present. It includes details for each discount and the timestamp for the next rotation.

```json
{
  "discounts": [
    {
      "model": "claude-3-5-sonnet",
      "percentage": 25,
      "expires_at": 1701716400,
      "time_remaining": "5h 23m"
    },
    {
      "model": "gpt-4o",
      "percentage": 15,
      "expires_at": 1701716400,
      "time_remaining": "5h 23m"
    }
  ],
  "next_rotation": 1701716400
}
```

--------------------------------

### Video Generation Response Example

Source: https://docs.voidai.app/api-reference/video/list

This is an example of the JSON response structure when listing video generation tasks. It includes an array of video objects and pagination details.

```JSON
{
  "data": [
    {
      "id": "vid_abc123",
      "status": "completed",
      "prompt": "A serene beach at sunset with gentle waves",
      "model": "sora-2",
      "created_at": 1701691200
    },
    {
      "id": "vid_def456",
      "status": "processing",
      "prompt": "A cat playing piano in a jazz club",
      "model": "sora-2",
      "created_at": 1701691100
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 10,
    "total": 25
  }
}
```

--------------------------------

### API Response Example for Listing Models

Source: https://docs.voidai.app/api-reference/models/list

This is an example of the JSON response structure when listing available models. It includes details like model ID, creation timestamp, and owner.

```json
{
  "object": "list",
  "data": [
    {
      "id": "gpt-4",
      "object": "model",
      "created": 1687882411,
      "owned_by": "openai"
    },
    {
      "id": "gpt-4o",
      "object": "model",
      "created": 1715367049,
      "owned_by": "openai"
    },
    {
      "id": "claude-3-5-sonnet",
      "object": "model",
      "created": 1718841600,
      "owned_by": "anthropic"
    },
    {
      "id": "gemini-2.0-flash",
      "object": "model",
      "created": 1701388800,
      "owned_by": "google"
    },
    {
      "id": "mistral-large",
      "object": "model",
      "created": 1708300800,
      "owned_by": "mistral"
    },
    {
      "id": "deepseek-chat",
      "object": "model",
      "created": 1704067200,
      "owned_by": "deepseek"
    }
  ]
}
```

--------------------------------

### Create Video Generation Task with Reference Image

Source: https://docs.voidai.app/api-reference/video/create

Submit a text prompt along with an optional reference image or video to guide the video generation. The reference file should be included in the `files` parameter.

```python
import requests

url = "https://api.voidai.app/v1/videos"
headers = {
    "Authorization": "Bearer sk-voidai-your_key_here"
}
data = {
    "model": "sora-2",
    "prompt": "Animate this scene with flowing water and moving clouds",
    "size": "1920x1080",
    "seconds": "5"
}
files = {
    "input_reference": open("reference.jpg", "rb")
}

response = requests.post(url, headers=headers, data=data, files=files)
video = response.json()
```

```bash
curl https://api.voidai.app/v1/videos \
  -H "Authorization: Bearer sk-voidai-your_key_here" \
  -F model="sora-2" \
  -F prompt="Animate this scene with flowing water and moving clouds" \
  -F size="1920x1080" \
  -F seconds="5" \
  -F input_reference="@reference.jpg"
```

--------------------------------

### Basic Chat Completion in Python

Source: https://docs.voidai.app/api-reference/chat/completions

Use this snippet to get a standard chat completion response. Ensure you have the OpenAI library installed and your API key and base URL are configured.

```python
from openai import OpenAI

client = OpenAI(
    api_key="sk-voidai-your_key_here",
    base_url="https://api.voidai.app/v1"
)

response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is the capital of France?"}
    ]
)

print(response.choices[0].message.content)
```

--------------------------------

### Video Generation Response Example

Source: https://docs.voidai.app/api-reference/video/create

This is an example of the JSON response received after submitting a video generation request. It includes the unique video ID, its current status, and the creation timestamp.

```json
{
  "id": "vid_abc123def456",
  "status": "pending",
  "created_at": 1701691200
}
```

--------------------------------

### Python Vision (Multimodal) Example

Source: https://docs.voidai.app/api-reference/chat/completions

Shows how to send an image along with a text prompt to the API using Python for multimodal understanding. It then prints the model's textual response to the image content.

```Python
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What's in this image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://example.com/image.jpg",
                        "detail": "high"
                    }
                }
            ]
        }
    ]
)

print(response.choices[0].message.content)
```

--------------------------------

### Basic Chat Completion in TypeScript

Source: https://docs.voidai.app/api-reference/chat/completions

This TypeScript example demonstrates how to perform a basic chat completion. It requires the 'openai' npm package and proper configuration of your API key and base URL.

```typescript
import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'sk-voidai-your_key_here',
  baseURL: 'https://api.voidai.app/v1'
});

const response = await client.chat.completions.create({
  model: 'gpt-4',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'What is the capital of France?' }
  ]
});

console.log(response.choices[0].message.content);
```

--------------------------------

### TypeScript Function Calling Example

Source: https://docs.voidai.app/api-reference/chat/completions

Illustrates how to set up tools and initiate a chat completion request using TypeScript for function calling. It verifies if a function call is suggested and logs the function name and its arguments.

```TypeScript
const tools = [
  {
    type: 'function' as const,
    function: {
      name: 'get_weather',
      description: 'Get the current weather in a location',
      parameters: {
        type: 'object',
        properties: {
          location: { type: 'string', description: 'The city name' },
          unit: { type: 'string', enum: ['celsius', 'fahrenheit'] }
        },
        required: ['location']
      }
    }
  }
];

const response = await client.chat.completions.create({
  model: 'gpt-4',
  messages: [{ role: 'user', content: "What's the weather in Tokyo?" }],
  tools,
  tool_choice: 'auto'
});

if (response.choices[0].message.tool_calls) {
  const toolCall = response.choices[0].message.tool_calls[0];
  console.log(`Function: ${toolCall.function.name}`);
  console.log(`Arguments: ${toolCall.function.arguments}`);
}
```

--------------------------------

### JSON Response Example

Source: https://docs.voidai.app/api-reference/audio/transcriptions

Example of the default JSON response format for audio transcription, containing the transcribed text.

```json
{
  "text": "Hello, this is a test transcription of an audio file."
}
```

--------------------------------

### Translate Audio with Prompt Guidance

Source: https://docs.voidai.app/api-reference/audio/translations

Provide optional text to guide the model's style and improve translation accuracy, especially for specific contexts like business meetings. The prompt should be in English.

```Python
with open("japanese_meeting.mp3", "rb") as audio_file:
    translation = client.audio.translations.create(
        model="whisper-1",
        file=audio_file,
        prompt="This is a business meeting discussion about quarterly sales."
    )
```

```cURL
curl https://api.voidai.app/v1/audio/translations \
    -H "Authorization: Bearer sk-voidai-your_key_here" \
    -F file="@japanese_meeting.mp3" \
    -F model="whisper-1" \
    -F prompt="This is a business meeting discussion about quarterly sales."
```

--------------------------------

### Model Not Found Error Response

Source: https://docs.voidai.app/api-reference/models/get

Example JSON response when the requested model does not exist.

```json
{
  "error": {
    "message": "Model 'invalid-model' not found",
    "type": "api_error",
    "code": "MODEL_NOT_FOUND"
  }
}
```

--------------------------------

### No Active Discounts Response Example

Source: https://docs.voidai.app/api-reference/discounts/my-discounts

This is a sample JSON response when no discounts are currently active. It returns an empty array for discounts but still provides the next rotation timestamp.

```json
{
  "discounts": [],
  "next_rotation": 1701716400
}
```

--------------------------------

### Translation Response Example

Source: https://docs.voidai.app/api-reference/audio/translations

This is an example of the JSON response format when translating audio. The 'text' field contains the translated English content.

```JSON
{
  "text": "Hello, welcome to our presentation. Today we will discuss the new features of our product."
}
```

--------------------------------

### Python Function Calling Example

Source: https://docs.voidai.app/api-reference/chat/completions

Demonstrates how to define tools and make a chat completion request in Python to enable function calling. Checks if the model intends to call a function and prints the function name and arguments.

```Python
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather in a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city name"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"]
                    }
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
    tools=tools,
    tool_choice="auto"
)

# Check if the model wants to call a function
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    print(f"Function: {tool_call.function.name}")
    print(f"Arguments: {tool_call.function.arguments}")
```

--------------------------------

### GET /v1/discounts/eligible-models

Source: https://docs.voidai.app/api-reference/discounts/eligible-models

Retrieves a list of all models that are eligible for the daily rotating discount program.

```APIDOC
## GET /v1/discounts/eligible-models

### Description
Get models eligible for discounts. Returns a list of all models that are eligible for the daily rotating discount program.

### Method
GET

### Endpoint
/v1/discounts/eligible-models

### Response
#### Success Response (200)
- **models** (array) - Array of model IDs that can receive discounts.
- **current_discounted** (array) - Array of model IDs currently receiving discounts.

### Request Example
```json
{
  "models": [
    "gpt-4",
    "gpt-4o",
    "claude-3-5-sonnet",
    "claude-3-opus",
    "gemini-2.0-flash",
    "gemini-1.5-pro",
    "mistral-large"
  ],
  "current_discounted": [
    "claude-3-5-sonnet",
    "gpt-4o"
  ]
}
```

### Examples

#### Python
```python
import requests

response = requests.get(
    "https://api.voidai.app/v1/discounts/eligible-models",
    headers={"Authorization": "Bearer sk-voidai-your_key_here"}
)

data = response.json()

print("Models eligible for discounts:")
for model in data["models"]:
    is_discounted = model in data["current_discounted"]
    status = " (DISCOUNTED NOW)" if is_discounted else ""
    print(f"  - {model}{status}")
```

#### TypeScript
```typescript
const response = await fetch('https://api.voidai.app/v1/discounts/eligible-models', {
  headers: {
    'Authorization': 'Bearer sk-voidai-your_key_here'
  }
});

const data = await response.json();

console.log('Models eligible for discounts:');
for (const model of data.models) {
  const isDiscounted = data.current_discounted.includes(model);
  const status = isDiscounted ? ' (DISCOUNTED NOW)' : '';
  console.log(`  - ${model}${status}`);
}
```

#### cURL
```bash
curl https://api.voidai.app/v1/discounts/eligible-models \
    -H "Authorization: Bearer sk-voidai-your_key_here"
```
```

--------------------------------

### TypeScript Vision (Multimodal) Example

Source: https://docs.voidai.app/api-reference/chat/completions

Demonstrates sending an image and text query to the API using TypeScript for multimodal processing. The resulting text content from the model's analysis of the image is then logged.

```TypeScript
const response = await client.chat.completions.create({
  model: 'gpt-4o',
  messages: [
    {
      role: 'user',
      content: [
        { type: 'text', text: "What's in this image?" },
        {
          type: 'image_url',
          image_url: {
            url: 'https://example.com/image.jpg',
            detail: 'high'
          }
        }
      ]
    }
  ]
});

console.log(response.choices[0].message.content);
```

--------------------------------

### API Response Example

Source: https://docs.voidai.app/api-reference/images/generations

This JSON structure represents a successful API call, detailing the created image's URL and the prompt that generated it. Ensure your application can parse this format.

```json
{
  "created": 1701691200,
  "data": [
    {
      "url": "https://storage.voidai.app/images/abc123.png",
      "revised_prompt": "A serene mountain landscape at sunset featuring snow-capped peaks reflecting in a crystal clear alpine lake, with warm orange and pink hues in the sky"
    }
  ]
}
```

--------------------------------

### Basic Image Generation

Source: https://docs.voidai.app/api-reference/images/generations

Generates an image from a text prompt using the specified model. Ensure you have the correct API key and base URL configured. This example uses DALL-E 3.

```Python
from openai import OpenAI

client = OpenAI(
    api_key="sk-voidai-your_key_here",
    base_url="https://api.voidai.app/v1"
)

response = client.images.generate(
    model="dall-e-3",
    prompt="A serene mountain landscape at sunset with a crystal clear lake",
    size="1024x1024",
    n=1
)

print(response.data[0].url)
```

```TypeScript
import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'sk-voidai-your_key_here',
  baseURL: 'https://api.voidai.app/v1'
});

const response = await client.images.generate({
  model: 'dall-e-3',
  prompt: 'A serene mountain landscape at sunset with a crystal clear lake',
  size: '1024x1024',
  n: 1
});

console.log(response.data[0].url)
```

```cURL
curl https://api.voidai.app/v1/images/generations \
  -H "Authorization: Bearer sk-voidai-your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "dall-e-3",
    "prompt": "A serene mountain landscape at sunset with a crystal clear lake",
    "size": "1024x1024",
    "n": 1
    }'
```

--------------------------------

### GET /v1/videos/{id}

Source: https://docs.voidai.app/api-reference/video/get

Retrieves the current status and details of a specific video generation task.

```APIDOC
## GET /v1/videos/{id}

### Description
Retrieves the current status and details of a specific video generation task.

### Method
GET

### Endpoint
/v1/videos/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The unique identifier of the video.

### Response
#### Success Response (200)
- **id** (string) - Unique identifier for the video.
- **status** (string) - Current status of the video generation: `pending`, `processing`, `completed`, `failed`.
- **prompt** (string) - The original prompt used for generation.
- **model** (string) - The model used for generation.
- **size** (string) - The dimensions of the video.
- **duration** (number) - The duration of the video in seconds (available when completed).
- **created_at** (integer) - Unix timestamp of when the task was created.
- **completed_at** (integer) - Unix timestamp of when the task completed (if applicable).
- **error** (string) - Error message if the generation failed.

### Response Example
#### Pending Video
```json
{
  "id": "vid_abc123",
  "status": "pending",
  "prompt": "A serene beach at sunset with gentle waves",
  "model": "sora-2",
  "size": "1920x1080",
  "created_at": 1701691200
}
```

#### Completed Video
```json
{
  "id": "vid_abc123",
  "status": "completed",
  "prompt": "A serene beach at sunset with gentle waves",
  "model": "sora-2",
  "size": "1920x1080",
  "duration": 10.0,
  "created_at": 1701691200,
  "completed_at": 1701691500
}
```

#### Failed Video
```json
{
  "id": "vid_abc123",
  "status": "failed",
  "prompt": "A serene beach at sunset with gentle waves",
  "model": "sora-2",
  "size": "1920x1080",
  "created_at": 1701691200,
  "error": "Content policy violation detected"
}
```
```

--------------------------------

### Get Model Details

Source: https://docs.voidai.app/api-reference/models/get

Use this to retrieve information about a specific model. Ensure you have your API key and base URL configured.

```python
from openai import OpenAI

client = OpenAI(
    api_key="sk-voidai-your_key_here",
    base_url="https://api.voidai.app/v1"
)

model = client.models.retrieve("gpt-4")

print(f"Model: {model.id}")
print(f"Provider: {model.owned_by}")
print(f"Created: {model.created}")
```

```typescript
import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'sk-voidai-your_key_here',
  baseURL: 'https://api.voidai.app/v1'
});

const model = await client.models.retrieve('gpt-4');

console.log(`Model: ${model.id}`);
console.log(`Provider: ${model.owned_by}`);
console.log(`Created: ${model.created}`);
```

```bash
curl https://api.voidai.app/v1/models/gpt-4
```

--------------------------------

### HD Quality with Natural Style

Source: https://docs.voidai.app/api-reference/images/generations

Generates an image with high definition quality and a natural artistic style. This example also uses DALL-E 3 and requires specifying the `quality` and `style` parameters.

```Python
response = client.images.generate(
    model="dall-e-3",
    prompt="A professional photograph of a coffee cup on a wooden table",
    size="1024x1024",
    quality="hd",
    style="natural",
    n=1
)
```

```TypeScript
const response = await client.images.generate({
  model: 'dall-e-3',
  prompt: 'A professional photograph of a coffee cup on a wooden table',
  size: '1024x1024',
  quality: 'hd',
  style: 'natural',
  n: 1
});
```

--------------------------------

### Check Active Discounts

Source: https://docs.voidai.app/api-reference/discounts/my-discounts

Use this endpoint to get details on your current discounts. Include your API key in the Authorization header. Discounts rotate daily around 6 PM CET.

```Python
import requests

response = requests.get(
    "https://api.voidai.app/v1/discounts/my-discounts",
    headers={"Authorization": "Bearer sk-voidai-your_key_here"}
)

data = response.json()

if data["discounts"]:
    print("Your active discounts:")
    for discount in data["discounts"]:
        print(f"  {discount['model']}: {discount['percentage']}% off")
        print(f"    Time remaining: {discount['time_remaining']}")
else:
    print("No active discounts")
```

```TypeScript
const response = await fetch('https://api.voidai.app/v1/discounts/my-discounts', {
  headers: {
    'Authorization': 'Bearer sk-voidai-your_key_here'
  }
});

const data = await response.json();

if (data.discounts.length > 0) {
  console.log('Your active discounts:');
  for (const discount of data.discounts) {
    console.log(`  ${discount.model}: ${discount.percentage}% off`);
    console.log(`    Time remaining: ${discount.time_remaining}`);
  }
} else {
  console.log('No active discounts');
}
```

```cURL
curl https://api.voidai.app/v1/discounts/my-discounts \
  -H "Authorization: Bearer sk-voidai-your_key_here"
```

--------------------------------

### Streaming Chat Completion in TypeScript

Source: https://docs.voidai.app/api-reference/chat/completions

This TypeScript example demonstrates how to handle streaming chat completions. The `stream: true` option enables chunked responses, which are processed iteratively.

```typescript
const stream = await client.chat.completions.create({
  model: 'gpt-4',
  messages: [{ role: 'user', content: 'Tell me a short story' }],
  stream: true
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content || '');
}
```

--------------------------------

### API Response Example

Source: https://docs.voidai.app/api-reference/chat/completions

A sample JSON structure representing a typical API response for a chat completion. It includes metadata like ID, creation timestamp, model used, choices, and token usage.

```JSON
{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1701691200,
  "model": "gpt-4",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "The capital of France is Paris."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 25,
    "completion_tokens": 8,
    "total_tokens": 33
  }
}
```

--------------------------------

### Basic Text-to-Speech Generation

Source: https://docs.voidai.app/api-reference/audio/speech

Generates audio from text using the `tts-1` model and the `alloy` voice. Ensure you have the OpenAI client library installed and your API key and base URL are configured.

```python
from openai import OpenAI

client = OpenAI(
    api_key="sk-voidai-your_key_here",
    base_url="https://api.voidai.app/v1"
)

response = client.audio.speech.create(
    model="tts-1",
    voice="alloy",
    input="Hello! This is a test of the text-to-speech API."
)

response.stream_to_file("output.mp3")

```

--------------------------------

### Get Eligible Models

Source: https://docs.voidai.app/api-reference/discounts/eligible-models

Use this endpoint to retrieve a list of all model IDs eligible for discounts and a list of model IDs currently receiving discounts. Ensure you include your API key in the Authorization header.

```Python
import requests

response = requests.get(
    "https://api.voidai.app/v1/discounts/eligible-models",
    headers={"Authorization": "Bearer sk-voidai-your_key_here"}
)

data = response.json()

print("Models eligible for discounts:")
for model in data["models"]:
    is_discounted = model in data["current_discounted"]
    status = " (DISCOUNTED NOW)" if is_discounted else ""
    print(f"  - {model}{status}")
```

```TypeScript
const response = await fetch('https://api.voidai.app/v1/discounts/eligible-models', {
  headers: {
    'Authorization': 'Bearer sk-voidai-your_key_here'
  }
});

const data = await response.json();

console.log('Models eligible for discounts:');
for (const model of data.models) {
  const isDiscounted = data.current_discounted.includes(model);
  const status = isDiscounted ? ' (DISCOUNTED NOW)' : '';
  console.log(`  - ${model}${status}`);
}
```

```cURL
curl https://api.voidai.app/v1/discounts/eligible-models \
    -H "Authorization: Bearer sk-voidai-your_key_here"
```

--------------------------------

### GET /v1/discounts/my-discounts

Source: https://docs.voidai.app/api-reference/discounts/my-discounts

Retrieves a list of currently active discounts for the authenticated user, along with details on when the next discount rotation will occur. Discounts are applied to specific models and have a percentage value and an expiration timestamp.

```APIDOC
## GET /v1/discounts/my-discounts

### Description
Get your active discounts and time remaining. Returns information about your currently active discounts, including the discount percentage and time remaining until the discount expires or rotates.

VoidAI offers daily rotating discounts on select models. Discounts typically rotate at 6 PM CET.

### Method
GET

### Endpoint
/v1/discounts/my-discounts

### Parameters
#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response (200)
- **discounts** (array) - Array of active discount objects.
  - **model** (string) - The model ID this discount applies to.
  - **percentage** (number) - The discount percentage (e.g., 20 for 20% off).
  - **expires_at** (integer) - Unix timestamp when this discount expires.
  - **time_remaining** (string) - Human-readable time remaining (e.g., "5h 23m").
- **next_rotation** (integer) - Unix timestamp of the next discount rotation.

#### Response Example
```json
{
  "discounts": [
    {
      "model": "claude-3-5-sonnet",
      "percentage": 25,
      "expires_at": 1701716400,
      "time_remaining": "5h 23m"
    },
    {
      "model": "gpt-4o",
      "percentage": 15,
      "expires_at": 1701716400,
      "time_remaining": "5h 23m"
    }
  ],
  "next_rotation": 1701716400
}
```

#### Response Example (No Active Discounts)
```json
{
  "discounts": [],
  "next_rotation": 1701716400
}
```
```

--------------------------------

### Edit Image with Mask (TypeScript)

Source: https://docs.voidai.app/api-reference/images/edits

This TypeScript example demonstrates how to edit an image using a mask. It requires initializing the OpenAI client with your API key and base URL, and uses Node.js streams for file handling.

```TypeScript
import OpenAI from 'openai';
import fs from 'fs';

const client = new OpenAI({
  apiKey: 'sk-voidai-your_key_here',
  baseURL: 'https://api.voidai.app/v1'
});

const response = await client.images.edit({
  model: 'dall-e-2',
  image: fs.createReadStream('original.png'),
  mask: fs.createReadStream('mask.png'),
  prompt: 'A sunlit indoor lounge area with a pool containing a flamingo',
  n: 1,
  size: '1024x1024'
});

console.log(response.data[0].url);
```

--------------------------------

### Video Generation Workflow - Create Video

Source: https://docs.voidai.app/api-reference/video/create

This Python snippet demonstrates the first step in the video generation workflow: submitting a prompt to create a video and retrieving its ID. Subsequent steps involve polling for status and downloading the video.

```python
import time
import requests

# 1. Create video
response = requests.post(
    "https://api.voidai.app/v1/videos",
    headers={"Authorization": "Bearer sk-voidai-your_key_here"},
    data={"model": "sora-2", "prompt": "A cat playing piano"}
)
video_id = response.json()["id"]
```

--------------------------------

### Complete Video Download Workflow

Source: https://docs.voidai.app/api-reference/video/download

This script demonstrates a full workflow: creating a video, polling its status until completion, and then downloading all available variants (video, thumbnail, spritesheet). Ensure the video has a 'completed' status before attempting downloads.

```Python
import time
import requests

headers = {"Authorization": "Bearer sk-voidai-your_key_here"}
base_url = "https://api.voidai.app/v1/videos"

# 1. Create video
create_response = requests.post(
    base_url,
    headers=headers,
    data={
        "model": "sora-2",
        "prompt": "A timelapse of clouds moving over a mountain",
        "size": "1920x1080",
        "seconds": "10"
    }
)
video_id = create_response.json()["id"]
print(f"Created video: {video_id}")

# 2. Wait for completion
while True:
    status_response = requests.get(f"{base_url}/{video_id}", headers=headers)
    status = status_response.json()["status"]

    if status == "completed":
        print("Video completed!")
        break
    elif status == "failed":
        print(f"Failed: {status_response.json().get('error')}")
        exit(1)

    print(f"Status: {status}")
    time.sleep(15)

# 3. Download all variants
variants = ["video", "thumbnail", "spritesheet"]
extensions = {"video": "mp4", "thumbnail": "webp", "spritesheet": "jpg"}

for variant in variants:
    response = requests.get(
        f"{base_url}/{video_id}/content",
        headers=headers,
        params={"variant": variant}
    )

    filename = f"output.{extensions[variant]}"
    with open(filename, "wb") as f:
        f.write(response.content)

    print(f"Downloaded {variant} as {filename}")


```

--------------------------------

### Moderation API Response Example

Source: https://docs.voidai.app/api-reference/moderations/create

An example of the JSON response structure from the Moderations API, detailing flagged status, categories, and confidence scores for each input.

```json
{
  "id": "modr-abc123",
  "model": "text-moderation-latest",
  "results": [
    {
      "flagged": false,
      "categories": {
        "hate": false,
        "hate/threatening": false,
        "harassment": false,
        "harassment/threatening": false,
        "self-harm": false,
        "self-harm/intent": false,
        "self-harm/instructions": false,
        "sexual": false,
        "sexual/minors": false,
        "violence": false,
        "violence/graphic": false
      },
      "category_scores": {
        "hate": 0.00001,
        "hate/threatening": 0.000001,
        "harassment": 0.00002,
        "harassment/threatening": 0.000001,
        "self-harm": 0.000001,
        "self-harm/intent": 0.000001,
        "self-harm/instructions": 0.000001,
        "sexual": 0.00001,
        "sexual/minors": 0.000001,
        "violence": 0.00003,
        "violence/graphic": 0.000001
      }
    }
  ]
}

```

--------------------------------

### POST /v1/videos

Source: https://docs.voidai.app/api-reference/video/create

Creates a video generation task from a text prompt. Video generation is asynchronous, returning a video ID for status checks and downloads.

```APIDOC
## POST /v1/videos

### Description
Generate videos from text prompts. This endpoint initiates an asynchronous video generation task and returns a video ID for subsequent status checks and downloads.

### Method
POST

### Endpoint
/v1/videos

### Parameters
#### Request Body
- **model** (string) - Required - The video generation model to use (e.g., `sora-2`).
- **prompt** (string) - Required - A text description of the video to generate.
- **size** (string) - Optional - The dimensions of the output video (e.g., `1920x1080`, `1080x1920`, `1280x720`).
- **seconds** (string) - Optional - The duration of the video in seconds.
- **input_reference** (file) - Optional - An optional reference image or video to guide generation.

### Request Example
```json
{
  "model": "sora-2",
  "prompt": "A serene beach at sunset with gentle waves",
  "size": "1920x1080",
  "seconds": "10"
}
```

### Response
#### Success Response (200)
- **id** (string) - Unique identifier for the video generation task.
- **status** (string) - The current status of the video generation. Possible values: `pending`, `processing`, `completed`, `failed`.
- **created_at** (integer) - Unix timestamp of when the task was created.

#### Response Example
```json
{
  "id": "vid_abc123def456",
  "status": "pending",
  "created_at": 1701691200
}
```
```

--------------------------------

### Get Model Details

Source: https://docs.voidai.app/api-reference/models/get

Retrieves information about a specific model. This endpoint does not require authentication.

```APIDOC
## GET /v1/models/{model}

### Description
Retrieves information about a specific model.

### Method
GET

### Endpoint
/v1/models/{model}

### Parameters
#### Path Parameters
- **model** (string) - Required - The model ID to retrieve (e.g., `gpt-4`, `claude-3-5-sonnet`).

### Response
#### Success Response (200)
- **id** (string) - The model identifier.
- **object** (string) - Always `model`.
- **created** (integer) - Unix timestamp of when the model was added.
- **owned_by** (string) - The organization that owns the model.

### Response Example
```json
{
  "id": "gpt-4",
  "object": "model",
  "created": 1687882411,
  "owned_by": "openai"
}
```

### Error Response
If the model doesn't exist:
```json
{
  "error": {
    "message": "Model 'invalid-model' not found",
    "type": "api_error",
    "code": "MODEL_NOT_FOUND"
  }
}
```
```

--------------------------------

### GET /v1/videos/{id}/content

Source: https://docs.voidai.app/api-reference/video/download

Downloads the content of a completed video. You can retrieve the video file, thumbnail, or spritesheet.

```APIDOC
## GET /v1/videos/{id}/content

### Description
Downloads the content of a completed video. Can retrieve the video file, thumbnail, or spritesheet.

### Method
GET

### Endpoint
/v1/videos/{id}/content

### Parameters
#### Path Parameters
- **id** (string) - required - The unique identifier of the video.

#### Query Parameters
- **variant** (string) - optional - The type of content to download:
  * `video` - The generated video file (MP4)
  * `thumbnail` - A thumbnail image (WebP)
  * `spritesheet` - A spritesheet preview (JPEG)

### Response
#### Success Response (200)
Returns the binary content of the requested file with the appropriate `Content-Type` header.
Variant| Content-Type  
---|---
`video`| `video/mp4`  
`thumbnail`| `image/webp`  
`spritesheet`| `image/jpeg`  

### Request Example
```json
{
  "example": "See Python, cURL examples in the documentation"
}
```

### Response Example
```json
{
  "example": "Binary content of the requested file"
}
```
```

--------------------------------

### Download Spritesheet

Source: https://docs.voidai.app/api-reference/video/download

Download a spritesheet preview for a video by setting the 'variant' query parameter to 'spritesheet'. The response will be binary JPEG data.

```Python
response = requests.get(
    f"https://api.voidai.app/v1/videos/{video_id}/content",
    headers={"Authorization": "Bearer sk-voidai-your_key_here"},
    params={"variant": "spritesheet"}
)

with open("spritesheet.jpg", "wb") as f:
    f.write(response.content)

```

```cURL
curl -X GET https://api.voidai.app/v1/videos/{id}/content?variant=spritesheet \
  -H "Authorization: Bearer sk-voidai-your_key_here" \
  --output spritesheet.jpg
```
Tokens:
Raw