# Claude, GPT and Gemini

> Call Claude, GPT and Gemini with one FlyMy.AI key: the FlyMy.AI API, the OpenAI-compatible API, or each maker's official SDK with only the base URL and the key changed. Billed per token, the charge on every answer.

The current chat models of Anthropic, OpenAI and Google are FlyMy.AI models,
each with its own endpoint id, such as `flymyai/claude-haiku-5-5`. Call them with
your FlyMy.AI key: every call is billed per token from your FlyMy.AI balance, at
the prices on the model's page, on the tokens the maker reports.

There are three ways to call one:

1. **The FlyMy.AI API** - `prompt` or `messages`, the same inputs and outputs for
   every model; from an assistant, `run_model` on the Agents MCP.
2. **The OpenAI-compatible API** - Chat Completions under the model's address.
3. **The maker's own API** under the model's address - OpenAI Responses,
   Anthropic Messages or Google `generateContent`. The official SDKs work with only
   the base URL and the key changed.

On 2 and 3 your request reaches the maker as you send it: function tools,
structured output, prompt caching and streaming work as the maker documents
them, and FlyMy.AI stores neither the prompt nor the answer.

## Models

| Model | Endpoint id | Maker's API | Maker's model id |
| --- | --- | --- | --- |
| Claude Fable 5.2 | `flymyai/claude-fable-5-2` | Anthropic Messages | `claude-fable-5-2` |
| Claude Opus 5.5 | `flymyai/claude-opus-5-5` | Anthropic Messages | `claude-opus-5-5` |
| Claude Sonnet 5.5 | `flymyai/claude-sonnet-5-5` | Anthropic Messages | `claude-sonnet-5-5` |
| Claude Haiku 5.5 | `flymyai/claude-haiku-5-5` | Anthropic Messages | `claude-haiku-5-5` |
| GPT-6 Astra | `flymyai/gpt-6-astra` | OpenAI Responses | `gpt-6-astra` |
| GPT-6.1 Sol | `flymyai/gpt-6_1-sol` | OpenAI Responses | `gpt-6.1-sol` |
| GPT-6.1 Terra | `flymyai/gpt-6_1-terra` | OpenAI Responses | `gpt-6.1-terra` |
| GPT-6 Luna | `flymyai/gpt-6-luna` | OpenAI Responses | `gpt-6-luna` |
| Gemini 4 Carbon | `flymyai/gemini-4-carbon` | Google `generateContent` | `gemini-4-carbon` |
| Gemini 4 Argon | `flymyai/gemini-4-argon` | Google `generateContent` | `gemini-4-argon` |
| Gemini 3.8 Flash | `flymyai/gemini-3_8-flash` | Google `generateContent` | `gemini-3.8-flash` |
| Gemini 3.5 Flash-Lite | `flymyai/gemini-3_5-flash-lite` | Google `generateContent` | `gemini-3.5-flash-lite` |

The model page, `https://app.flymy.ai/models/<endpoint id>`, lists its prices,
reasoning efforts, context window and longest answer. The endpoint id has no dots;
the maker's model id is what the maker's SDK expects in `model` (the address picks
the model, so a different `model` value does not switch it).

## Addresses and keys

A model's address is `https://api.flymy.ai/api/v1/<endpoint id>`, for example
`https://api.flymy.ai/api/v1/flymyai/claude-haiku-5-5`. Your FlyMy.AI key goes
where each SDK puts its own key.

| API | Base URL | Key |
| --- | --- | --- |
| FlyMy.AI API | `POST <address>/predict` | `X-API-KEY` |
| Chat Completions, every model | `<address>/openai/v1` | `Authorization: Bearer` |
| OpenAI Responses, GPT | `<address>/openai/v1` | `Authorization: Bearer` |
| Anthropic Messages, Claude | `<address>/anthropic` | `x-api-key` |
| Google `generateContent` and `streamGenerateContent`, Gemini | `<address>/google` (`v1beta`) | `x-goog-api-key` |

Another maker's API under a model's address answers `400`.

## OpenAI SDK - Responses API

```python
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.flymy.ai/api/v1/flymyai/gpt-6-luna/openai/v1",
    api_key=os.environ["FLYMYAI_API_KEY"],
)

response = client.responses.create(
    model="gpt-6-luna",
    input="Write a haiku about the sea.",
)
print(response.output_text)
```

Responses are not stored at OpenAI: send the conversation in `input` instead of
`previous_response_id`. GPT-6 Astra, GPT-6.1 Sol and GPT-6.1 Terra take function
tools on the Responses API only; GPT-6 Luna takes them on Chat Completions only
with `reasoning_effort` `none`.

## Anthropic SDK - Messages API

```python
import os
import anthropic

client = anthropic.Anthropic(
    base_url="https://api.flymy.ai/api/v1/flymyai/claude-haiku-5-5/anthropic",
    api_key=os.environ["FLYMYAI_API_KEY"],
)

message = client.messages.create(
    model="claude-haiku-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Write a haiku about the sea."}],
)
print("".join(block.text for block in message.content if block.type == "text"))
```

On Chat Completions, Anthropic's compatibility layer, Claude ignores
`reasoning_effort` and has no prompt caching: use the Messages API for those and
for PDF documents.

## Google GenAI SDK - generateContent

```python
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_5-flash-lite/google",
        api_version="v1beta",
    ),
)

response = client.models.generate_content(
    model="gemini-3.5-flash-lite",
    contents="Write a haiku about the sea.",
)
print(response.text)
```

`generate_content_stream` streams. On this route Gemini also takes audio, video
and PDF, inline or by a public URL.

## OpenAI-compatible API

Every model here answers Chat Completions under `<address>/openai/v1`:

```python
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.flymy.ai/api/v1/flymyai/gemini-3_5-flash-lite/openai/v1",
    api_key=os.environ["FLYMYAI_API_KEY"],
)

response = client.chat.completions.create(
    model="gemini-3.5-flash-lite",
    messages=[{"role": "user", "content": "Write a haiku about the sea."}],
)
print(response.choices[0].message.content)
print(response.usage)
```

For these models the request goes to the maker as you send it, so the
parameter table of [OpenAI-Compatible API](https://docs.flymy.ai/guides/llm-openai-compat.md) does not apply
to them: the maker's own Chat Completions rules do.

## FlyMy.AI API

```bash
curl -X POST https://api.flymy.ai/api/v1/flymyai/claude-haiku-5-5/predict \
  -H "X-API-KEY: $FLYMYAI_API_KEY" \
  -F "prompt=Write a haiku about the sea." \
  -F "reasoning_effort=low"
```

| Input | |
| --- | --- |
| `prompt` | One user message |
| `messages` | Chat history as a JSON array of `{role, content}`; used instead of `prompt`. Text and `image_url` parts |
| `system_prompt` | Instructions for the whole chat |
| `reasoning_effort` | The model's levels, listed on its page |
| `max_tokens` | Most tokens to generate, reasoning included |
| `private_mode` | `true` keeps the prompt and the answer out of FlyMy.AI storage and logs (synchronous calls only) |

`output_data` holds `output` (the answer), `finish_reason`, `model`,
`stream_details` (tokens read, cached, written to the cache and reasoned) and
`charge_usd`, the price of the call. From an assistant connected to the Agents MCP:

```text
run_model({"endpoint_id":"flymyai/claude-haiku-5-5",
  "input":{"prompt":"Write a haiku about the sea."}})
```

## The charge of every answer

An answer that is not streamed carries its price in the header
`x-flymy-cost-usd`; Chat Completions also puts it in `usage.cost`. The FlyMy.AI
API returns `charge_usd`.

## Not offered

- Tools the makers run themselves: web search, code execution, file search,
  image generation and the like.
- The makers' files and batch APIs, and anything they would store for you:
  stored responses and conversations, Google's context caches.
- Fast, flex, priority and other non-default tiers.

A request that asks for one of them is refused with `400` before anything is
charged.

## Next

- [OpenAI-Compatible API](https://docs.flymy.ai/guides/llm-openai-compat.md)
- [Using LLMs](https://docs.flymy.ai/guides/use-llms.md)
- [Errors](https://docs.flymy.ai/errors.md)