How to Use Claude and GPT Through One API — The 97AI.PRO Unified Gateway Guide
by•
<!--
SEO / GEO front-matter (fill into your platform's meta fields — dev.to, Hashnode, Medium, Ghost)
Title: How to Use Claude and GPT Through One API — The 97AI.PRO Unified Gateway Guide
Slug: claude-gpt-one-openai-compatible-api-97ai
Meta desc: Call Claude and GPT from one OpenAI-compatible API. Switch models by changing one field, pay 30–84% less, and skip juggling two SDKs. Working Python/Node/cURL code.
Primary kw: OpenAI-compatible API, Claude API, GPT API, unified LLM gateway
Secondary kw: multi-model API, AI API aggregator, cheaper Claude GPT API, switch LLM by model field, LLM gateway pattern
Canonical: https://97ai.97claude.com
Tags: ai, api, llm, python, webdev
-->
# How to Use Claude and GPT Through One API — The 97AI.PRO Unified Gateway Guide
**TL;DR** — Instead of maintaining two SDKs, two keys, and two billing accounts for Anthropic and OpenAI, you can call **Claude and GPT through a single OpenAI-compatible endpoint**. You switch models by changing one string (`"model"`), pay roughly **30–84% less** than official list prices, and never pay for failed generations. Below is working `cURL` / Python / Node.js code you can run today.
---
## The problem: "using one model" is a myth in real products
If you build AI features for a living, two things bite you fast:
1. **Protocols don't match.** Anthropic's Messages API and OpenAI's Chat Completions API differ in fields, auth, and billing.
2. **Real apps use several models.** Claude is strong at long-context analysis and steady writing; GPT is strong at general generation and tool/function calling; you often want Gemini or Grok on standby too.
The cost of wiring up multiple official APIs isn't just the sticker price — it's the **engineering tax**: two SDK code paths, two key-management flows, two billing reconciliations, region-locked payment cards, and the quiet cost of failed calls during batch experiments.
The moment your model count grows from 2 → 5 → 10+, that tax scales non-linearly. The fix is an old idea applied to LLMs: **put a gateway in front of the providers.**
---
## The architecture: one gateway, four layers
1. **Application layer** — your business logic (chat, RAG, copywriting, code assistant, support summaries). It depends on *one* calling interface, not on any vendor.
2. **Unified model service** — a thin `ModelGateway` you own: timeout, retry, logging, error-code mapping, cost metrics.
3. **97AI.PRO API gateway** — one OpenAI-compatible endpoint, one key, one balance. Claude, GPT, Gemini and **150+ models** share it.
4. **Model providers** — Claude / GPT / Gemini / Grok / image & video models behind the gateway. Protocol differences are absorbed here.
---
## The whole trick: switch models by changing one field
- **Base URL:** `https://97ai.97claude.com/v1`
- **Auth:** `Authorization: Bearer <YOUR_API_KEY>`
- **Model switch:** change `"model"`. Common choices:
- `gpt-5-6-terra`, `gpt-5-5` — general generation, tool calls, code
- `claude-opus-4-8`, `claude-sonnet-5` — long-context analysis, robust writing
- `gemini-3-pro` — multimodal, very long context
Because the endpoint is **OpenAI-compatible**, any OpenAI SDK works unchanged — you only swap the `base_url`.
---
## Working code (run it as-is, just add your key)
### cURL — smoke test
```bash
curl https://97ai.97claude.com/v1/cha... \
-H "Authorization: Bearer $YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "claude-opus-4-8",
"messages": [{"role": "user", "content": "Explain RAG in three sentences."}]
}'
```
Change `"model"` to `"gpt-5-6-terra"` to hit GPT instead — **nothing else changes.**
### Python — the official `openai` SDK
```python
# pip install openai (no anthropic SDK needed)
from openai import OpenAI
client = OpenAI(
api_key="YOUR_97AI_API_KEY",
base_url="https://97ai.97claude.com/v1", # the only change
)
def call(model: str, prompt: str) -> str:
r = client.chat.completions.create(
model=model,
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": prompt},
],
temperature=0.7,
max_tokens=1024,
)
return r.choices[0].message.content
# Same code, different vendor — decided by `model`
print(call("gpt-5-6-terra", "Summarize the core goal of this spec."))
print(call("claude-opus-4-8", "Analyze the logical structure of this long text."))
```
### Node.js — the official `openai` package
```javascript
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.YOUR_97AI_API_KEY,
baseURL: "https://97ai.97claude.com/v1",
});
async function call(model, content) {
const r = await client.chat.completions.create({
model,
messages: [
{ role: "system", content: "You are a helpful assistant." },
{ role: "user", content },
],
temperature: 0.7,
max_tokens: 1024,
});
return r.choices[0].message.content;
}
console.log(await call("gpt-5-5", "Write a product blurb."));
console.log(await call("claude-sonnet-5", "Extract the key points from these minutes."));
```
### Streaming (SSE)
```python
stream = client.chat.completions.create(
model="claude-opus-4-8",
messages=[{"role": "user", "content": "Write a 300-word product story."}],
stream=True,
)
for chunk in stream:
print(chunk.choices[0].delta.content or "", end="", flush=True)
```
### Recommended: a tiny routing layer
Never hardcode model names into business flows. Route by task, so changing strategy is a one-line edit:
```python
MODEL_BY_TASK = {
"long_context_analysis": "claude-opus-4-8", # long docs, deep analysis
"general_generation": "gpt-5-6-terra", # generation, tool calls
"cheap_batch": "gemini-3-flash", # high-volume, cost-first
}
def route(task: str) -> str:
return MODEL_BY_TASK.get(task, "gpt-5-6-terra")
```
---
## Cost: how much cheaper, exactly?
Public example prices (check the pricing page for live rates):
| Item | Official | 97AI.PRO | Savings |
|---|---|---|---|
| Claude Opus 4.7 — input | $5.00 / M tokens | **$1.425 / M** | ~71.5% |
| GPT-5.5 — output | $30 / M tokens | **$8.40 / M** | ~72% |
| Veo 3.1 4K — video | $4.80 / clip | **$1.85 / clip** | ~61.4% |
Two structural cost wins beyond the sticker price: **failed generations are billed $0** (zero-risk billing — great for batch A/B testing), and everything runs off **one balance** instead of N reconciliations.
---
## Direct connect vs. self-built multi-vendor vs. unified gateway
| Criteria | Single official API | Self-built multi-vendor | 97AI.PRO unified |
|---|---|---|---|
| Models available | limited to one vendor | as many as you wire up | 150+ |
| Interface consistency | medium | low | high (OpenAI-compatible) |
| Model-switch cost | medium | high | low (change `model`) |
| Failed-call billing | per vendor rules | per vendor rules | **always $0** |
| Payments | usually intl. card only | your problem | card / USDC / Alipay / WeChat |
| Min top-up | varies | varies | **$5** |
| Mainland-China access | vendor-dependent | your problem | direct |
**Who should pick what**
- **Solo devs / small teams** — value speed, easy payment, cheap iteration → unified gateway.
- **Global / cross-border teams** — value USDC/Alipay, multilingual UI, flexible switching → unified gateway.
- **Multi-model product teams** — Claude *and* GPT, not either/or → unified gateway beats deep single-vendor lock-in.
- **Very large enterprises** — weigh SLA, audit, compliance, private deployment; aggregation fits efficiency-first work, while extreme custom protocol control may keep some direct connections.
---
## Pitfalls when wiring Claude + GPT
1. **Don't hardcode model names** — route via config/env (see the routing table).
2. **Mind context windows & output style** — Claude and GPT differ on detail retention and structured output; pick per task.
3. **Standardize errors & retries** — handle timeouts, 429 rate limits, 5xx, and context-too-long distinctly.
4. **Observe cost** — track success rate, latency, daily token spend, and per-task cost.
5. **Ship with canary routing** — roll a new default model to 5% → 10% → 30% before full switch.
---
## FAQ
**Can I use the OpenAI SDK to call Claude?**
Yes. Point the OpenAI SDK's `base_url` at `https://97ai.97claude.com/v1` and set `model` to `claude-opus-4-8` (or `claude-sonnet-5`). No Anthropic SDK required.
**How do I switch between Claude and GPT?**
Change the `model` field only — e.g. `claude-opus-4-8` ↔ `gpt-5-6-terra`. Request body, auth, and SDK stay the same.
**Is it really cheaper than official APIs?**
On public example prices, roughly 30–84% cheaper (e.g. GPT-5.5 output $8.40/M vs $30/M official). Failed generations cost $0.
**Do I pay for failed requests?**
No. Billing is zero-risk — you're only charged for successful outputs.
**What payment methods and regions are supported?**
Credit card, USDC (Arbitrum), Alipay, and WeChat Pay; minimum top-up $5; works from mainland China without a VPN.
**How many models are available through one key?**
150+ — chat (Claude, GPT, Gemini, Grok, Mistral, Cohere, Kimi) plus image, video, and music models.
---
## Bottom line
The real question isn't "how do I write the request" — it's "how do I fold multi-model capability into one maintainable framework." For a single model, direct connect is fine. But once you're in multi-model, multi-scenario, multi-region-payment, many-experiments territory, a unified gateway pays for itself: **one API, one key, one balance** in front of 150+ models — cheaper, with failed calls free, global payments, and direct China access.
> Sample code runs as-is once you add your API key. In production, follow the OWASP API Security Top 10 (auth, rate-limiting, request validation, auditing), redact sensitive data in logs, and confirm each model's parameter support and live price in the 97AI.PRO docs.
1 view
Replies