One LLM API key for GPT, Claude and Gemini: three ways to call 37 models

What an LLM API is, and why one key

An LLM API is a web endpoint for a large language model: you send a request with your key, the maker's servers run the model, and you get the answer back as text, all at once or as a stream. You pay for the tokens the model reads and writes. Every maker has its own: OpenAI has Chat Completions and the Responses API, Anthropic has the Messages API, and Google has generateContent. Each comes with its own account, its own key, its own SDK and its own bill.

That is fine while you use one model. It gets in the way when you want to try Claude on the prompt you wrote for GPT, move a feature to Gemini, or let an agent pick the model per task. With FlyMy.AI, one key and one balance reach the current chat models of all three makers: a unified LLM API in which you still call each model in the API format its maker documents.

What's new on FlyMy.AI

From 12 November 2026, the chat models of OpenAI, Anthropic and Google are a new family of models on FlyMy.AI, with a new way to call them. Each model is a project with its own address, https://api.flymy.ai/api/v1/flymyai/<name>, and the platform log lists the change.

The models you can call

The 12 models listed on app.flymy.ai/models are the current ones of each maker. The project name goes into the address, and the address decides which model answers; in the model field of a request, write the maker's model id.

Swipe the table sideways to see every column.

The other 25 are earlier versions and previews. They are not listed in the app and answer the same way at their addresses:

Prices from the FlyMy.AI catalog on 12 November 2026, per 1M tokens. A long prompt costs more where the maker says so: over 272,000 tokens on GPT-6.1 Sol ($4.00 input, $15.00 output) and the other GPT models that list a long-context price, over 100,000 tokens on Claude Haiku 5.5 ($0.50 input, $2.50 output) and over 200,000 tokens on Gemini 3.1 Pro (preview) ($4.00 input, $18.00 output). Google's introductory prices end for Gemini 4 Carbon and Gemini 4 Argon on 30 November 2026 ($4.00 input, $0.20 cached input and $20.00 output from 1 December) and for Gemini 3.8 Flash and Gemini 3.7 Flash on 31 December 2026 ($1.50, $0.15 and $7.50 from 1 January 2027). Gemini 4 Carbon and Argon write at most 32,768 tokens per request, 65,536 when streamed.

How to call an LLM API with one key, step by step

1. Get your FlyMy.AI API key

Sign in at app.flymy.ai and copy your API key from your Developers page. Keep it in an environment variable, never in your code or a shared repository:

export FLYMYAI_API_KEY="your FlyMy.AI key"

2. Pick the model and take its address

Every model lives at https://api.flymy.ai/api/v1/flymyai/<name>, with the project name from the tables above: claude-sonnet-5-5, gpt-6_1-sol, gemini-3_8-flash and so on.

3. Choose how to call it

• A prompt and a text answer, or an AI assistant: the FlyMyAI API and MCP.
• Code that already uses the OpenAI SDK, with Claude, Gemini or GPT: the OpenAI-compatible API.
• Everything the maker's API offers for that model, such as Anthropic's prompt caching or OpenAI's Responses: the maker's own API and SDK.

4. Read the charge

A complete answer names what the call cost in the x-flymy-cost-usd header. A Chat Completions answer also carries it in usage.cost, streamed answers included. With the official SDKs, read the header from the raw response:

raw = client.messages.with_raw_response.create(
    model="claude-haiku-5-5",
    max_tokens=256,
    messages=[{"role": "user", "content": "Say hello."}],
)
print(raw.headers["x-flymy-cost-usd"])  # the charge in USD
message = raw.parse()

Way 1: the FlyMyAI API and MCP

The simplest call: send a prompt, get text. The model's page in the app shows the inputs: prompt, or a chat history in messages; system_prompt for instructions; reasoning_effort with the levels the model offers; max_tokens to cap the answer; and private_mode to keep the prompt and the answer out of FlyMyAI storage and logs (synchronous calls only).

curl https://api.flymy.ai/api/v1/flymyai/claude-haiku-5-5/predict \
  -H "X-API-KEY: $FLYMYAI_API_KEY" \
  -d prompt="Explain in two sentences why the sky is blue." \
  -d max_tokens=256

The answer comes as a short event stream whose last event holds the text in output_data.output. The same call is the tool run_model of the FlyMy.AI MCP, so Claude, ChatGPT, Cursor and Codex can call these models for you. Ask in plain words:

Use Claude Haiku 5.5 on FlyMy.AI to explain in two sentences why the sky is blue.

Way 2: an OpenAI-compatible API for Claude, Gemini and GPT

34 of the 37 models answer OpenAI's Chat Completions under their own address; the three GPT Pro models (GPT-5.5 Pro, GPT-5.4 Pro and GPT-5.2 Pro) answer on the Responses API only. Point the OpenAI SDK at the model's base URL and pass your FlyMy.AI key; the rest of your code stays as it is, streaming included.

base_url = https://api.flymy.ai/api/v1/flymyai/<name>/openai/v1

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.flymy.ai/api/v1/flymyai/claude-sonnet-5-5/openai/v1",
    api_key=os.environ["FLYMYAI_API_KEY"],
)
completion = client.chat.completions.create(
    model="claude-sonnet-5-5",
    messages=[{"role": "user", "content": "Write a haiku about latency."}],
)
print(completion.choices[0].message.content)
print(completion.usage.cost)  # the charge in USD

The same request with curl, to Gemini 3.8 Flash:

curl https://api.flymy.ai/api/v1/flymyai/gemini-3_8-flash/openai/v1/chat/completions \
  -H "Authorization: Bearer $FLYMYAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gemini-3.8-flash",
       "messages": [{"role": "user", "content": "Write a haiku about latency."}]}'

For a GPT model this is OpenAI's own Chat Completions; for Claude and Gemini it is the maker's OpenAI-compatible endpoint, with that maker's limits. Claude's ignores reasoning_effort and has no prompt caching, so use the Messages API for either. Some models take a feature on one API only: GPT-6.1 Sol takes function tools on the Responses API, not on Chat Completions. Each model's page in the app says so. More in the docs: OpenAI-compatible API.

Way 3: the maker's own API and SDK

Each model also answers its maker's own API under its address, so the official SDK works with two changes: the base URL and the key. Your request reaches the maker as you send it, and the answer comes back as the maker sent it.

OpenAI Responses API

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.flymy.ai/api/v1/flymyai/gpt-6_1-sol/openai/v1",
    api_key=os.environ["FLYMYAI_API_KEY"],
)
response = client.responses.create(
    model="gpt-6.1-sol",
    input="Summarize the plot of Hamlet in three sentences.",
    reasoning={"effort": "low"},
)
print(response.output_text)

Send the conversation in input each turn: responses stored at OpenAI, previous_response_id and background mode are not offered.

Anthropic Messages API

The Anthropic base URL is the model's address plus /anthropic; the SDK adds /v1/messages and sends the key as x-api-key.

import os
import anthropic

client = anthropic.Anthropic(
    base_url="https://api.flymy.ai/api/v1/flymyai/claude-sonnet-5-5/anthropic",
    api_key=os.environ["FLYMYAI_API_KEY"],
)
message = client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Summarize the plot of Hamlet in three sentences."}],
)
print("".join(block.text for block in message.content if block.type == "text"))

Prompt caching works as Anthropic documents it: mark the long, stable part of the prompt with "cache_control": {"type": "ephemeral"}, and the next calls read it at the cached input price.

Google generateContent (Gemini API)

import os
from google import genai
from google.genai import types

client = genai.Client(
    api_key=os.environ["FLYMYAI_API_KEY"],
    http_options=types.HttpOptions(
        base_url="https://api.flymy.ai/api/v1/flymyai/gemini-3_8-flash/google"
    ),
)
response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents="Summarize the plot of Hamlet in three sentences.",
)
print(response.text)

The same call over HTTP, with the key in the x-goog-api-key header:

curl "https://api.flymy.ai/api/v1/flymyai/gemini-3_8-flash/google/v1beta/models/gemini-3.8-flash:generateContent" \
  -H "x-goog-api-key: $FLYMYAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"contents": [{"role": "user", "parts": [{"text": "Summarize the plot of Hamlet in three sentences."}]}]}'

The routes, headers and bodies in these examples are the ones our production check of 12 November 2026 sent to a model of each maker, plain and streamed.

What works, and what is not offered

On the OpenAI-compatible endpoint and the makers' own APIs, the request reaches the maker as you send it. The model is the one in the address. FlyMyAI stores neither the prompt nor the answer on those routes.

LLM API pricing per 1M tokens

FlyMy.AI bills each call per token at the maker's list price: the fresh input, the cached input, the cache writes where the maker bills them, and the output, reasoning included. The price is the same as the maker's own; what changes is that one balance pays for all three makers. Here are the 12 listed models side by side; the prices of the 25 others are in the table above.

• Claude API pricing: Claude Haiku 5.5 $0.10 input and $0.50 output, Claude Sonnet 5.5 $2.00 input and $10.00 output, Claude Opus 5.5 $4.00 input and $20.00 output, Claude Fable 5.2 $8.00 input and $40.00 output per 1M tokens.
• OpenAI API pricing: GPT-6 Luna $0.10 input and $0.50 output, GPT-6.1 Terra $1.00 input and $5.00 output, GPT-6.1 Sol $2.00 input and $10.00 output, GPT-6 Astra $10.00 input and $50.00 output per 1M tokens.
• Gemini API pricing: Gemini 3.5 Flash-Lite $0.30 input and $2.50 output, Gemini 3.8 Flash $0.75 input and $3.75 output, Gemini 4 Argon $2.00 input and $10.00 output, Gemini 4 Carbon $2.00 input and $10.00 output per 1M tokens.

For prices of other kinds of models and tools, see the pricing page.

Use cases with ready prompts

Paste these into Claude, ChatGPT, Cursor or Codex with the FlyMy.AI MCP connected, or into a coding agent working in your repository.

1. Compare two models on your own prompt

The fastest way to choose: the same prompt to two makers, answers side by side.

Ask Claude Sonnet 5.5 and GPT-6.1 Sol on FlyMy.AI the same question and show me both answers side by side: what are three risks of caching LLM answers in a support chatbot?

2. Move an OpenAI SDK app to Claude or Gemini

Two lines change: the base URL and the key. A coding agent can make the change and keep the key out of the code.

In this repository, point the OpenAI client at FlyMy.AI: base URL https://api.flymy.ai/api/v1/flymyai/claude-sonnet-5-5/openai/v1, model claude-sonnet-5-5, and the key from the FLYMYAI_API_KEY environment variable. Do not put the key in the code.

3. Turn notes into decisions

A cheap, fast model is enough for structured extraction.

Use Gemini 3.8 Flash on FlyMy.AI to turn these meeting notes into a list of decisions, each with an owner and a date: [paste your notes]

Keep reading

• Models on FlyMy.AIEvery public model with its inputs, price and setup.
• OpenAI-compatible API docsThe base URL, streaming and usage in detail.
• One MCP, 1,500+ toolsModels, agents and the services they work with.
• Platform logWhat is new on FlyMy.AI, release by release.
• How to build an AI agent with ClaudeEvery agent lives in a project.
• PricingWhat models and tools cost on FlyMy.AI.