GenMagic

Hosted MCP server for 450+ AI models: generate images, video, speech, music and text with one API key and one pay-as-you-go balance. Pick any model by id (list_models shows ids and prices) or let GenMagic choose; video is billed only when it completes.

View on genmagic.coTry this MCPSponsored

Hosted MCP Server

npx add-mcp 'https://genmagic.co/api/mcp'

Installs into Claude Code, Codex, Cursor and more

Documentation

The GenMagic API

OpenAI-compatible endpoints for every text and vision model, for image generation, for speech and music, and for video, a typed /text call for on-brand artifacts, plus an MCP server for agents. Point any OpenAI SDK at your base URL, drop in a key, and ship. A call from your code costs exactly what a call from the studio costs: the same credit balance, at the same price. Every modality the studio makes, your code makes too.

Base URL and authentication

The API is served from your GenMagic domain under /api/v1. Authenticate with a secret key in the Authorization header. Create keys in your account settings; a key is shown once, so store it somewhere safe.

https://genmagic.co/api/v1

Authorization: Bearer gm_live_...

Keep keys server-side. Never embed a key in a browser bundle or mobile app: anyone who reads it can spend your credits.

Your first call

POST /chat/completions is the core call. It is OpenAI-compatible, so the official OpenAI SDKs work unchanged: just set the base URL and your GenMagic key.

curl https://genmagic.co/api/v1/chat/completions \
  -H "Authorization: Bearer $GENMAGIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5",
    "messages": [{ "role": "user", "content": "Write a haiku about shipping fast." }]
  }'

from openai import OpenAI

client = OpenAI(
    base_url="https://genmagic.co/api/v1",
    api_key="YOUR_GENMAGIC_API_KEY",
)

resp = client.chat.completions.create(
    model="anthropic/claude-sonnet-5",
    messages=[{"role": "user", "content": "Write a haiku about shipping fast."}],
)
print(resp.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://genmagic.co/api/v1",
  apiKey: process.env.GENMAGIC_API_KEY,
});

const resp = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-5",
  messages: [{ role: "user", content: "Write a haiku about shipping fast." }],
});
console.log(resp.choices[0].message.content);

Streaming

Set "stream": true to receive tokens as server-sent events, in the same chunk format OpenAI uses. Usage is metered from the provider’s authoritative token count when the stream finishes.

curl https://genmagic.co/api/v1/chat/completions \
  -H "Authorization: Bearer $GENMAGIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5",
    "stream": true,
    "messages": [{ "role": "user", "content": "Stream a short story." }]
  }'

Reasoning, parameters and caching

/chat/completions forwards your request body to the model unchanged, so every parameter the model supports works as sent: temperature, tools, response_format, seed and the rest. Each model lists the ones it honours in supported_parameters on GET /models.

Reasoning models take reasoning_effort, or the object form reasoning: { effort, enabled, max_tokens }. The effort values a model accepts are in its capabilities.reasoning_efforts; when capabilities.reasoning_mandatory is true, thinking cannot be switched off and "enabled": false is refused with a 400. Reasoning tokens are reported in usage.completion_tokens_details.reasoning_tokens.

curl https://genmagic.co/api/v1/chat/completions \
  -H "Authorization: Bearer $GENMAGIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-oss-120b",
    "reasoning_effort": "high",
    "messages": [{ "role": "user", "content": "How many weekdays are there in March 2027?" }]
  }'

Every call bills the model provider’s own usage cost, so cached input and long prompts cost what the model charges for them: cached input tokens at pricing.cache_read_usd_per_million (cache writes at cache_write_usd_per_million) where a model publishes them, and a prompt that reaches a band’s min_prompt_tokens in pricing.tiers at that band’s prices.

Generate

Typed, on-brand text

POST /text returns a specific text ARTIFACT, steered on-brand the way the studio does: pass a type and get back the finished thing. With brand personalization on, an svg and a website come out in your exact palette and typeface, and writing and code carry your voice. This is the difference from /chat/completions: that endpoint is the raw OpenAI-compatible model call (your brand VOICE is applied, but it has no notion of an artifact type), while /text adds the type’s system prompt and, for svg / website, the visual palette and typeface. An SVG is returned with content-provenance metadata embedded.

type is one of writing, code, svg, or website (omit it for a plain, voice-branded generation). Each type picks a sensible default model, or set model yourself from /models. Optional system adds an extra steer on top of your brand, and attachments let the model read a reference image, PDF, or document.

curl https://genmagic.co/api/v1/text \
  -H "Authorization: Bearer $GENMAGIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "svg",
    "prompt": "A geometric mountain badge, flat, three shapes"
  }'
# -> { "created": ..., "model": "...", "type": "svg", "text": "<svg ...>...</svg>",
#      "usage": { "input_tokens": ..., "output_tokens": ... } }

curl (a landing page in your brand)

curl https://genmagic.co/api/v1/text \
  -H "Authorization: Bearer $GENMAGIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "website",
    "prompt": "A landing page for a small-batch coffee roaster, warm and minimal"
  }'

import requests

r = requests.post(
    "https://genmagic.co/api/v1/text",
    headers={"Authorization": "Bearer YOUR_GENMAGIC_API_KEY"},
    json={"type": "svg", "prompt": "A minimalist wifi icon"},
).json()
print(r["text"])

The response is { created, model, type?, text, usage }. Cost and the balance left come back in the X-Cost-Cents and X-Credits-Remaining headers (see Errors), the same as every metered call. An svg or website generated with brand personalization on also returns X-Brand-Fit (on_brand, wrong_palette, or monochrome): a read-back of the artifact’s colors (the vector’s fills, or the page’s CSS), so you can regenerate one that came out off your palette. It is a best-effort hint, present only when the output could be measured against a brand color.

Images

POST /images/generations generates images, in OpenAI’s image shape, so client.images.generate(...) works unchanged. Choose any image model from /models (or omit model for the recommended default). Set size (e.g. 1024x1024, 1792x1024) and response_format (url or b64_json).

Image-to-image (references). Pass an image (an https URL or a data:image URL) to TRANSFORM that image instead of generating from scratch: send a character or product and it is kept, not replaced. The model receives the reference (an unusable one is rejected, never silently dropped). Add "type": "logo" to steer the result as a brand mark. The reference reaches the model identically to the studio.

curl https://genmagic.co/api/v1/images/generations \
  -H "Authorization: Bearer $GENMAGIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "google/gemini-3.1-flash-image",
    "prompt": "A cobalt prism refracting into a spectrum, dark studio, 3D render",
    "size": "1024x1024"
  }'

curl https://genmagic.co/api/v1/images/generations \
  -H "Authorization: Bearer $GENMAGIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "the same character as a marble statue on a plinth",
    "image": "https://your-cdn.com/green-frog-knight.png"
  }'

from openai import OpenAI

client = OpenAI(base_url="https://genmagic.co/api/v1", api_key="YOUR_GENMAGIC_API_KEY")

img = client.images.generate(
    model="google/gemini-3.1-flash-image",
    prompt="A cobalt prism refracting into a spectrum, dark studio, 3D render",
    size="1024x1024",
)
print(img.data[0].url)

Speech and music

POST /audio/speech turns text into spoken audio, in OpenAI’s speech shape, so client.audio.speech.create(...) works unchanged. POST /audio/music generates an original music track from a description. Both return the raw audio bytes (the model’s native container, e.g. audio/mpeg); the durable hosted URL comes back in the X-Media-Url response header.

curl https://genmagic.co/api/v1/audio/speech \
  -H "Authorization: Bearer $GENMAGIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": "Welcome to the future of on-brand generation.",
    "voice": "alloy"
  }' --output speech.mp3

from openai import OpenAI

client = OpenAI(base_url="https://genmagic.co/api/v1", api_key="YOUR_GENMAGIC_API_KEY")

with client.audio.speech.with_streaming_response.create(
    model="openai/gpt-audio-mini",
    voice="alloy",
    input="Welcome to the future of on-brand generation.",
) as response:
    response.stream_to_file("speech.mp3")

curl https://genmagic.co/api/v1/audio/music \
  -H "Authorization: Bearer $GENMAGIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "warm lo-fi hip hop, mellow keys, soft vinyl crackle, 80 bpm"
  }' --output track.wav

With brand personalization on, music is nudged on-brand in mood automatically. Speech is voiced verbatim, so it is never altered.

Generate

Video

Video is asynchronous (a clip takes seconds to minutes), so it is a two-step, poll-based flow. POST /videos starts a job and returns its id immediately; then poll GET /videos/{id} until status is completed, at which point you get a durable url. Nothing is charged until the clip completes, and a finished job is billed exactly once no matter how many times you poll it.

Clips are made from your prompt, so pick a model whose capabilities.text_to_video is true in GET /models?category=video (or omit model for the default). Models that edit, upscale or animate media you supply are listed with false and refused with 400 model_not_supported.

curl https://genmagic.co/api/v1/videos \
  -H "Authorization: Bearer $GENMAGIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "a paper boat sailing down a rain gutter, cinematic, slow motion",
    "aspect_ratio": "16:9"
  }'
# -> { "id": "vid_...", "status": "queued", "status_url": "/api/v1/videos/vid_..." }

curl https://genmagic.co/api/v1/videos/vid_... \
  -H "Authorization: Bearer $GENMAGIC_API_KEY"
# -> { "status": "processing" }   ... keep polling ...
# -> { "status": "completed", "url": "https://.../clip.mp4", "cost_cents": 25 }

import time, requests

base = "https://genmagic.co/api/v1"
headers = {"Authorization": "Bearer YOUR_GENMAGIC_API_KEY"}

job = requests.post(f"{base}/videos", headers=headers, json={
    "prompt": "a paper boat sailing down a rain gutter, cinematic, slow motion",
    "aspect_ratio": "16:9",
}).json()

while True:
    s = requests.get(f"{base}/videos/{job['id']}", headers=headers).json()
    if s["status"] in ("completed", "failed"):
        break
    time.sleep(3)

print(s.get("url") or s.get("error"))

With brand personalization on, the clip is steered on-brand (palette and aesthetic) automatically, exactly like an image. Statuses are queued, processing, completed, and failed.

Listing models

GET /models returns every model available right now, in OpenAI’s list shape, with each model’s full detail: name, description, context length, input/output modalities, capabilities (reasoning, vision, tools, structured output, voices), pricing in each model’s real unit (a unit of token, image, minute, or second, with usd_per_unit, and for video the per-second range plus every supported resolution and clip length), and benchmark scores where published. The catalog is live: new models appear the day they launch, no SDK update required. This is a pure lookup: it needs no API key and spends no credits. A request that does send a key has the key checked and counted toward its per-key rate limit (see Errors), so cache the catalog and refresh it periodically rather than polling on a tight loop.

Filter with ?category= (text, image, audio, video), ?capability= (reasoning, vision, tools, structured), and ?search= (id or name). Retrieve one model with GET /models/{id} (the id contains a slash, e.g. /models/openai/gpt-image-2).

# Every model, full detail
curl https://genmagic.co/api/v1/models \
  -H "Authorization: Bearer $GENMAGIC_API_KEY"

# Only image models
curl "https://genmagic.co/api/v1/models?category=image" \
  -H "Authorization: Bearer $GENMAGIC_API_KEY"

# One model's details
curl https://genmagic.co/api/v1/models/openai/gpt-image-2 \
  -H "Authorization: Bearer $GENMAGIC_API_KEY"

The list returns { "object": "list", "data": [ ... ] }; each entry (and the retrieve response) is one model object. Text models carry per-token pricing (prompt_usd_per_million, completion_usd_per_million, and where the model publishes them cache_read_usd_per_million, cache_write_usd_per_million, reasoning_usd_per_million and long-context tiers), the request parameters they honour in supported_parameters, and for reasoning models capabilities.reasoning_efforts and reasoning_mandatory (see Reasoning); image, audio, and video carry a per-generation estimate. Every model also carries a single comparable est_per_generation_usd.

{
  "id": "openai/gpt-image-2",
  "object": "model",
  "created": 1751068800,
  "owned_by": "openai",
  "name": "OpenAI: GPT Image 2",
  "description": "Image generation and editing model.",
  "category": "image",
  "input_modalities": ["text", "image"],
  "output_modalities": ["image"],
  "context_length": 0,
  "capabilities": {
    "reasoning": false,
    "reasoning_by_default": false,
    "vision": true,
    "tools": false,
    "structured_output": false
  },
  "pricing": {
    "currency": "USD",
    "unit": "generation",
    "image_output_usd_per_token": 0.00003,
    "est_per_generation_usd": 0.0387
  }
}

Your agent, over the API

POST /agent/turn is the API face of your GenMagic agent: send a conversation and it replies in character AND returns the set of assets to make across modalities, on brand. It plans, you make. Planning is not billed; you then generate each returned asset by calling the endpoint for its modality (/chat/completions for text, /images/generations for image, /audio/speech or /audio/music for audio, /videos for video).

curl https://genmagic.co/api/v1/agent/turn \
  -H "Authorization: Bearer $GENMAGIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      { "role": "user", "content": "Make a launch tweet and a logo for a cold brew brand called Northwind." }
    ]
  }'

The response is { reply, assets: [{ modality, title, prompt, aspect_ratio?, voice? }] }. Feed each asset’s prompt to the matching endpoint to generate it.

Agents

Use it from an agent (MCP)

GenMagic is also a Model Context Protocol server, so an AI agent can generate through it directly. Point any MCP client (Claude Desktop, Cursor, or your own) at the endpoint below with your key, and the agent gets seven tools: generate_text, generate_image, generate_speech, generate_music, for video create_video + get_video (create returns a job id, get_video polls it until the clip is ready), and list_models. A tool call is billed exactly like any other call, and comes out on-brand when personalization is on.

Any model, by id. Every generate tool takes an optional model: the same ids as the REST API and the model library. The agent finds them with list_models (filter by category or search), which needs no key and returns each model’s price, the voices of speech models and the resolutions, clip lengths and sound support of video models, plus the default each tool runs when no model is named. create_video also takes duration, resolution and generate_audio. An id that a tool does not run is refused with a pointer to list_models, never swapped for another model, and every result names the model that ran.

https://genmagic.co/api/mcp

Most clients take a small config with the URL and an Authorization header:

{
  "mcpServers": {
    "genmagic": {
      "url": "https://genmagic.co/api/mcp",
      "headers": { "Authorization": "Bearer $GENMAGIC_API_KEY" }
    }
  }
}

Under the hood it is plain JSON-RPC, so you can call it with anything:

curl https://genmagic.co/api/mcp \
  -H "Authorization: Bearer $GENMAGIC_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{ "jsonrpc": "2.0", "id": 1, "method": "tools/list" }'

curl (list video models with their prices and options; no key needed)

curl https://genmagic.co/api/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "jsonrpc": "2.0", "id": 5, "method": "tools/call",
    "params": { "name": "list_models", "arguments": { "category": "video", "limit": 10 } }
  }'

curl (generate an image with a chosen model)

curl https://genmagic.co/api/mcp \
  -H "Authorization: Bearer $GENMAGIC_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "jsonrpc": "2.0", "id": 2, "method": "tools/call",
    "params": {
      "name": "generate_image",
      "arguments": {
        "prompt": "a cobalt prism on black, 3D render",
        "size": "1024x1024",
        "model": "google/gemini-nano-banana-2.1"
      }
    }
  }'

curl https://genmagic.co/api/mcp \
  -H "Authorization: Bearer $GENMAGIC_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "jsonrpc": "2.0", "id": 3, "method": "tools/call",
    "params": {
      "name": "generate_music",
      "arguments": { "prompt": "warm lo-fi hip hop, mellow keys, 80 bpm" }
    }
  }'

curl (start a video, then poll get_video)

curl https://genmagic.co/api/mcp \
  -H "Authorization: Bearer $GENMAGIC_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "jsonrpc": "2.0", "id": 4, "method": "tools/call",
    "params": {
      "name": "create_video",
      "arguments": {
        "prompt": "a paper boat sailing down a rain gutter, cinematic",
        "aspect_ratio": "16:9",
        "model": "google/veo-3.1-fast",
        "duration": 8,
        "resolution": "720p"
      }
    }
  }'
# then poll: params.name "get_video", arguments { "id": "<the returned job id>" }

Every tool result self-describes its spend. A JSON-RPC body has no per-call headers, so each tool result carries its metering in the standard MCP _meta field, under the key genmagic.ai/usage: cost_cents (what the call cost), credits_remaining (your balance after it), and a rate object (limit, remaining, reset). It is the MCP mirror of the REST response headers below, so an agent paces itself and tracks spend from the result it already has. A create_video submit and a still-rendering get_video poll charge nothing, so they report rate headroom only; the clip’s cost lands on the poll that completes it. Fields are omitted, never faked, when a value is unknown.

Visual calls also report brand fit. When you generate a logo, a branded svg, or a branded website and your brand has a color set, the result’s _meta carries a brand_fit object: label is on_brand, wrong_palette (the output came out in an off-brand color, worth regenerating), or monochrome (intentionally colorless, not a problem), alongside a presence fraction and a foreign_dominant_hue flag. An agent can read it and regenerate an artifact that drifted off-brand, without a human in the loop. It is present only when the output could actually be measured, so it is simply absent for prose/code calls or a format we do not decode.

Integrations

Use it with the Vercel AI SDK

GenMagic works with the Vercel AI SDK through its OpenAI-compatible provider, so there is no GenMagic package to install. Create the provider with your base URL and API key, then use generateText, streamText, tool calling, and generateImage with any model id from the catalog.

npm install ai @ai-sdk/openai-compatible

import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { generateText, streamText } from "ai";

const genmagic = createOpenAICompatible({
  name: "genmagic",
  apiKey: process.env.GENMAGIC_API_KEY,
  baseURL: "https://genmagic.co/api/v1",
  includeUsage: true, // token usage on streamed responses too
});

const { text } = await generateText({
  model: genmagic("anthropic/claude-sonnet-5"),
  prompt: "Write a haiku about shipping fast.",
});

const result = streamText({
  model: genmagic("google/gemini-3.5-flash"),
  prompt: "Count from 1 to 5, separated by spaces.",
});
for await (const part of result.textStream) process.stdout.write(part);

Images go through generateImage. The AI SDK reads images as base64, so ask for b64_json with a provider option keyed by the provider name you chose:

import { generateImage } from "ai";

const { image } = await generateImage({
  model: genmagic.imageModel("recraft/recraft-v4.1-flash"),
  prompt: "A watercolor fox reading a book under a tree",
  providerOptions: { genmagic: { response_format: "b64_json" } },
});
// image.uint8Array, image.base64, image.mediaType

Model ids come from GET /models, which needs no key (filter with ?category=text or ?category=image). Tool calling works with models whose capabilities.tools is true. Speech, music, and video use the REST endpoints above. Tested on 2026-10-03 with ai 7.0.127 and @ai-sdk/openai-compatible 3.0.62, and with ai 6.0.300 and @ai-sdk/openai-compatible 2.0.81.

Integrations

Use it in Dify

GenMagic is a plugin in the Dify Marketplace, so the workflows and agents you build in Dify can generate with it too. Install the plugin, paste your API key into its settings, and you get six tools: Generate image, Generate video and Check video, Generate speech, Generate music, and Generate text. Each tool lists the live models with their prices (or lets GenMagic pick one) and returns the generated file to the workflow.

The plugin is free; generations draw on the same credit balance as every other call. Its source is on GitHub.

Use it in n8n

GenMagic is a community node for n8n, published on npm as n8n-nodes-genmagic. On a self-hosted n8n, an owner or admin opens Settings › Community Nodes, selects Install, and enters the package name:

n8n-nodes-genmagic

Then add a GenMagic API credential with your key (n8n checks it by reading your balance, which costs nothing). One node covers Image (generate, or edit a reference image, up to 4 per run), Video (generate, waiting for the render or returning the job id, and get), Audio (speech and music), Text, Model (the live catalog), and Account (your balance). Each model dropdown lists the live catalog with prices, or lets GenMagic pick. Generated files come back as binary data, ready for the nodes that upload, post, or email them, with the generation’s cost_usd and your remaining balance_usd. n8n’s AI Agent can use the node as a tool, too.

The node is free and MIT-licensed; generations draw on the same credit balance as every other call. Its source is on GitHub.

Integrations

Use it in Zapier

GenMagic has a Zapier integration in beta. Until Zapier lists it in its app directory, you add it to your Zapier account with this invite link, then connect it with your API key (Zapier checks the key by reading your balance, which costs nothing). Any Zap can then use five steps: Generate Image (a picture or a logo, optionally from a reference image), Generate Text (writing, code, an SVG graphic or a web page), Generate Speech, Start Video, and Find Video. Each model field lists the live catalog with prices, or leave it empty to use the default.

Zapier gives every step 30 seconds, so video takes two steps: Start Video returns a job ID right away, and Find Video, in a later step or Zap, returns the clip once it is finished. Image and speech steps return a hosted file URL and text steps the text, each with the call’s cost_usd; Find Video adds the clip’s cost when it completes. The integration is free; generations draw on the same credit balance as every other call.

Integrations

Try it in Postman

Every endpoint is ready to send in GenMagic’s public Postman workspace, imported from the OpenAPI spec. Fork the GenMagic API collection into your own workspace, set its Bearer token to your key, and send any request. GET /models answers without a key, so you can browse the live catalog and its prices first.

Billing

Credits: a call is a call

There is no separate API meter. Every generation, from the studio or from your code, is billed the same way: the provider’s real cost is deducted from your one credit balance. Top up or subscribe from your account, and the same balance powers both.

If a call would run your balance negative it is refused with HTTP 402 and an insufficient_quota error, exactly as an OpenAI SDK expects, so your retry and error handling work without changes.

See pricing

Errors

Every error uses the OpenAI envelope, so an OpenAI SDK parses it without changes: { "error": { "message", "type", "code", "param" } }. The status codes:

400  invalid_request_error   bad or missing parameter (e.g. no prompt, unknown model id)
401  authentication_error    missing, invalid, or revoked API key
402  insufficient_quota      balance would go negative; top up to continue
404  invalid_request_error   model_not_found on GET /models/{id}
429  rate_limit_error        too many requests for this key; back off and retry
5xx  server_error            transient upstream/provider issue; retry with backoff

Lookup calls (/models, /usage) spend no credits, so they never return a 402: they only ever return 401 (bad key), 429 (rate limited), or, for a missing model, 404.

Rate limits. Each key allows up to 300 requests per minute (fixed window). Exceeding it returns 429 with a Retry-After header (seconds until the window resets) alongside X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset. Honor Retry-After and retry. This paces a leaked key; your credit balance is the real spend bound. Need a higher limit for a heavy workload? Ask us to raise it on your key.

Response headers. Every successful call reports its own metering, so an agent can pace itself and track spend without a second request. The rate-limit trio (X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset) is on every authenticated response, including lookups, and X-Credits-Remaining reports your balance after any non-streaming call that spent credits. Image, audio, video, and typed /text generations also carry X-Cost-Cents (what that call cost); a video reports its cost on the poll that completes it, and /text additionally returns its token counts in the response usage object. Chat completions instead price the OpenAI way with no X-Cost-Cents: the token counts are in the response usage object (in the terminal SSE frame when streaming, which is why a streamed call carries only the rate headers). A logo generation (and a branded svg or website from /text) also carries X-Brand-Fit (on_brand, wrong_palette, or monochrome), the compact form of the MCP brand_fit object above, present only when the output could be measured. Values are best-effort hints; GET /usage remains the authoritative balance.

Check your balance

GET /usage returns your key’s live credit balance and lifetime spend, so a program or agent can check its remaining budget before a big run and never be surprised by a 402. It reads the same balance every other call draws on.

curl https://genmagic.co/api/v1/usage \
  -H "Authorization: Bearer $GENMAGIC_API_KEY"
# -> { "object": "usage", "currency": "usd",
#      "balance_cents": 3812.5, "balance_usd": 38.125,
#      "spent_cents": 2187.5, "spent_usd": 21.875, "generation_count": 148 }

On-brand

Personalization

Open Personalize your outputs in the app and connect your website or LinkedIn once. GenMagic learns your voice, audience, and colors. While personalization is on, every API generation is automatically shaped by that brand profile: your responses come out on-brand without changing a line of your code.

It is a single switch. Turn it off there and API calls run exactly as written, with no brand context added. Your prompts and system messages are always preserved; the brand context is prepended as a leading system message only while the switch is on.