const client = new OpenAI({
  apiKey: process.env.VELOKEY_API_KEY,
  baseURL: process.env.VELOKEY_BASE_URL,
});
const response = await client.chat.completions.create({
  model: selectedModel,
  messages,
});
return response;

const client = new OpenAI({
  apiKey: process.env.VELOKEY_API_KEY,
  baseURL: process.env.VELOKEY_BASE_URL,
});
const response = await client.chat.completions.create({
  model: selectedModel,
  messages,
});
return response;

const client = new OpenAI({
  apiKey: process.env.VELOKEY_API_KEY,
  baseURL: process.env.VELOKEY_BASE_URL,
});
const response = await client.chat.completions.create({
  model: selectedModel,
  messages,
});
return response;

const client = new OpenAI({
  apiKey: process.env.VELOKEY_API_KEY,
  baseURL: process.env.VELOKEY_BASE_URL,
});
const response = await client.chat.completions.create({
  model: selectedModel,
  messages,
});
return response;

const client = new OpenAI({
  apiKey: process.env.VELOKEY_API_KEY,
  baseURL: process.env.VELOKEY_BASE_URL,
});
const response = await client.chat.completions.create({
  model: selectedModel,
  messages,
});
return response;

const client = new OpenAI({
  apiKey: process.env.VELOKEY_API_KEY,
  baseURL: process.env.VELOKEY_BASE_URL,
});
const response = await client.chat.completions.create({
  model: selectedModel,
  messages,
});
return response;

const client = new OpenAI({
  apiKey: process.env.VELOKEY_API_KEY,
  baseURL: process.env.VELOKEY_BASE_URL,
});
const response = await client.chat.completions.create({
  model: selectedModel,
  messages,
});
return response;

const client = new OpenAI({
  apiKey: process.env.VELOKEY_API_KEY,
  baseURL: process.env.VELOKEY_BASE_URL,
});
const response = await client.chat.completions.create({
  model: selectedModel,
  messages,
});
return response;

const client = new OpenAI({
  apiKey: process.env.VELOKEY_API_KEY,
  baseURL: process.env.VELOKEY_BASE_URL,
});
const response = await client.chat.completions.create({
  model: selectedModel,
  messages,
});
return response;

const client = new OpenAI({
  apiKey: process.env.VELOKEY_API_KEY,
  baseURL: process.env.VELOKEY_BASE_URL,
});
const response = await client.chat.completions.create({
  model: selectedModel,
  messages,
});
return response;

const client = new OpenAI({
  apiKey: process.env.VELOKEY_API_KEY,
  baseURL: process.env.VELOKEY_BASE_URL,
});
const response = await client.chat.completions.create({
  model: selectedModel,
  messages,
});
return response;

const client = new OpenAI({
  apiKey: process.env.VELOKEY_API_KEY,
  baseURL: process.env.VELOKEY_BASE_URL,
});
const response = await client.chat.completions.create({
  model: selectedModel,
  messages,
});
return response;

Models: Text / Image / Video

Billing: Pay as you go

Data: No training use

Text, image, and video models. One API.

Access Top AI Models
Through One API

Build with leading text, image, and video models on one reliable, cost-effective API platform. Switch models without rebuilding integrations, and pay only for what you use.

Get Your API Key

OpenAI-compatiblePay as you goTransparent pricingNo prompt or output retention

02 WHY VELOKEY.

One integration.
More models. Less overhead.

Direct providers mean separate accounts, API keys, billing systems, and integration patterns. Velokey gives your team one place to access, compare, and operate the models your product needs.

/01

One API across providers

Use one familiar API format to access models from different providers. Add or switch models without rebuilding your application stack.

View API docs

/02

Choose by capability and price

Compare model capabilities, billing units, and pricing before you integrate. Pick the model that fits each workload.

Compare models

/03

Designed for reliable access

Use route health, usage records, and fallback options to operate model workloads with fewer blind spots.

See reliability

/ 03 - MODELS

One API for text, image, and video models

Explore models by modality, capability, and price. Start with the right model today and switch when your requirements change.

/01 / VIDEOLive

Video Generation APIs

Build text-to-video and image-to-video workflows with models such as Seedance, Kling, Veo, and Wan. Compare resolution, duration, features, and price per second.

Explore Video APIs

Featured models

Seedance / Kling / Veo / Wan

Pricing

Per-second pricing

Route

Choose by duration, resolution, and features

Best for

Ads, product demos, creative workflows

/02 / IMAGELive

Image Generation APIs

Generate and edit images with GPT Image, Nano Banana, Seedream, Qwen Image, and more. Choose by output quality, editing support, and price per image.

Explore Image APIs

Featured models

GPT Image / Nano Banana / Seedream / Qwen

Pricing

Per-image pricing

Route

Choose by quality, editing, and resolution

Best for

Product images, ads, and visual assets

/03 / LLMLive

LLM APIs

Build chat, reasoning, coding, and agent workflows with GPT, Claude, Gemini, DeepSeek, and other leading language models through one interface.

Explore LLM API

Featured models

GPT / Claude / Gemini / DeepSeek

Pricing

Token-based pricing

Route

Choose by context, latency, and price

Need a faster model route.

Router picked GPT fallback.

message...

Best for

Chat, reasoning, coding, and agents

Switch Models with One Familiar API

Keep your existing OpenAI-compatible client. Update your Base URL and API key, then choose the model you want to call.

velokey - OpenAI-compatible quickstart

from openai import OpenAI

client = OpenAI(api_key="YOUR_VELOKEY_API_KEY", base_url="YOUR_VELOKEY_BASE_URL")

response = client.chat.completions.create(model="YOUR_MODEL_ID", messages=[...])

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

From API Key to First Call in Minutes

If you already use an OpenAI-compatible SDK, migration starts with a Base URL and API key change.

1

Create your API key

Create an account and generate a key from the Velokey console.

Get API key View docs

2

Update your Base URL

Keep your existing SDK and point it to the Velokey endpoint.

View docs Try online

3

Choose a model and build

Call text, image, and video models through one account and interface.

velokey.ai - demo.request

curl --request POST \
  --url <VELOKEY_BASE_URL>/chat/completions \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "<MODEL_ID>",
    "messages": [
      {
        "role": "user",
        "content": "Tell me about artificial intelligence."
      }
    ]
  }'

/ 04 - COMPARE

Compare models
before you commit

Evaluate models by capability, context, speed, billing unit, and price before adding them to your workflow.

GPT API family

Compare GPT models across reasoning, coding, context and cost for general intelligence tasks from prototype to production.

reasoningcodingchatcost

Compare models

Claude API family

Compare Claude models for coding agents, complex reasoning and stable long-context workflows.

agentcodinglong contextreasoning

Compare models

Gemini API family

Compare Gemini models across reasoning, multimodal tasks, speed and cost efficiency.

reasoningmultimodalfastvalue

Compare models

Image & Video Models

Compare visual generation models by modality, editing support, resolution, duration, and cost.

generationeditingresolutioncost

Compare models

/ 05 - PRODUCTION

Reliable access. Transparent operation.

Understand how requests are routed, what each call costs, and what happens when an upstream route becomes unavailable.

Route health you can see

Monitor availability, latency, and errors across supported routes.

> availability: monitored

> errors: visible

Automatic failover

When multiple routes are available, failed requests can move to a healthy fallback route.

request → velokey.ai router

|- latency check

`- automatic failover

One console, full control

Usage

Spend

Track request status, token usage, latency, errors, and spend from one place.

Transparent model pricing

Pay as you gopricing mode

See token, image, and video pricing before you call. Pay only for actual usage.

/ 07 - FAQ

Common questions

Key details about pricing, migration, model access, reliability, and data handling on Velokey.

Velokey is a unified AI API platform for accessing leading text, image, and video models through one account, API key, and integration.

Velokey uses pay-as-you-go pricing. Language models are billed by token usage, while image and video billing units depend on the selected model. Prices are visible before you call.

If your app already uses an OpenAI-compatible SDK, migration starts by changing the Base URL and API key. You can then choose a supported model without replacing the rest of your client.

Velokey focuses on leading language, image, and video models. The model catalog shows currently available models, versions, capabilities, and pricing.

When multiple healthy routes are available and failover is enabled, Velokey can move requests to a fallback route based on availability, latency, and cost.

Velokey does not retain prompt or model-output content and does not use customer API data for training. Limited operational metadata is retained for billing, security, troubleshooting, and support.

Access Top AI ModelsThrough One API

One integration.More models. Less overhead.

One API across providers

Choose by capability and price

Designed for reliable access

One API for text, image, and video models

Video Generation APIs

Image Generation APIs

LLM APIs

Create your API key

Update your Base URL

Choose a model and build

Compare modelsbefore you commit

GPT API family

Claude API family

Gemini API family

Image & Video Models

Reliable access. Transparent operation.

Route health you can see

Automatic failover

One console, full control

Transparent model pricing

Common questions

Access Top AI Models
Through One API

One integration.
More models. Less overhead.

Compare models
before you commit