LemonData logoLemonData

Settings

Language
Blog

Migrate from OpenAI to LemonData in 5 Minutes

L
LemonData
·February 26, 2026·517 views
Migrate from OpenAI to LemonData in 5 Minutes

Switching from OpenAI's official API to LemonData takes two line changes. Your existing code, prompts, and model names all work as-is. You also get access to 300+ models across OpenAI, Anthropic, Google, DeepSeek, and more, through the same API key.

If you are comparing gateway choices before you migrate, read the pricing comparison and OpenRouter vs LemonData comparison. If your team needs a region-specific playbook, the China developer guide covers the payment and operational side.

The Short Version

  1. Sign up at lemondata.cc and grab an API key (you get $1 free credit)
  2. Replace your base_url and api_key
  3. Done. Everything else stays the same.

Python (OpenAI SDK)

# Before: OpenAI official
from openai import OpenAI
client = OpenAI(api_key="sk-openai-xxx")

# After: LemonData (change 2 lines)
from openai import OpenAI
client = OpenAI(
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

# Everything else stays the same
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)

Streaming, function calling, vision: all work identically. The OpenAI Python SDK sends requests to whatever base_url you point it at.

Node.js (OpenAI SDK)

// Before: OpenAI official
import OpenAI from 'openai';
const openai = new OpenAI({ apiKey: 'sk-openai-xxx' });

// After: LemonData (change 2 lines)
import OpenAI from 'openai';
const openai = new OpenAI({
  apiKey: 'sk-lemon-xxx',
  baseURL: 'https://api.lemondata.cc/v1',
});

// Everything else stays the same
const completion = await openai.chat.completions.create({
  model: 'gpt-4.1',
  messages: [{ role: 'user', content: 'Hello!' }],
});
console.log(completion.choices[0].message.content);

Note: it's baseURL (camelCase) in the Node.js SDK, not base_url.

curl

# Before: OpenAI official
curl https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer sk-openai-xxx" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4.1","messages":[{"role":"user","content":"Hello"}]}'

# After: LemonData (change URL and key)
curl https://api.lemondata.cc/v1/chat/completions \
  -H "Authorization: Bearer sk-lemon-xxx" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4.1","messages":[{"role":"user","content":"Hello"}]}'

Same endpoint path, same request body, same response format.

Environment Variable Approach

If your code reads from environment variables (which it should), you don't even need to touch code:

# Before
export OPENAI_API_KEY="sk-openai-xxx"
export OPENAI_BASE_URL="https://api.openai.com/v1"

# After
export OPENAI_API_KEY="sk-lemon-xxx"
export OPENAI_BASE_URL="https://api.lemondata.cc/v1"

The OpenAI SDK automatically reads OPENAI_API_KEY and OPENAI_BASE_URL from the environment. Zero code changes.

What You Get After Migration

Once you're on LemonData, you keep full OpenAI compatibility and gain access to additional capabilities:

300+ Models, One API Key

Your existing OpenAI code now works with Claude, Gemini, DeepSeek, Mistral, and hundreds more. In many cases, the only thing you need to change is the model parameter:

# GPT-4.1 (OpenAI): $2.00/$8.00 per 1M tokens
response = client.chat.completions.create(model="gpt-4.1", messages=messages)

# Claude Sonnet 4.6 (Anthropic): $3.00/$15.00 per 1M tokens
response = client.chat.completions.create(model="claude-sonnet-4-6", messages=messages)

# Gemini 2.5 Pro (Google)
response = client.chat.completions.create(model="gemini-2.5-pro", messages=messages)

# DeepSeek V3: $0.28/$0.42 per 1M tokens (use "deepseek-chat" or alias "deepseek-v3")
response = client.chat.completions.create(model="deepseek-chat", messages=messages)

Multi-channel redundancy means if one upstream provider has issues, the gateway automatically routes to an alternative channel. No code changes needed.

Native Protocol Access (Optional)

If you want to use Anthropic or Google models with their full native capabilities (extended thinking, prompt caching with cache_control, Google search grounding), LemonData supports their native protocols through the same base URL:

# Anthropic native: use the Anthropic SDK
# Extended thinking, cache_control, Citations all work natively
from anthropic import Anthropic
client = Anthropic(
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc"  # No /v1. Anthropic SDK adds /v1/messages itself.
)

# Google Gemini native: use the Google SDK
# Search grounding, grounding_metadata all work natively
from google import genai
client = genai.Client(
    api_key="sk-lemon-xxx",
    http_options={"base_url": "https://api.lemondata.cc"}  # No path suffix. SDK adds /v1beta/models/... itself.
)

This is entirely optional. The OpenAI-compatible endpoint works for all models. But if you need Anthropic's extended thinking or Google's grounding, native protocol access gives you those features without any format conversion loss.

What Usually Changes During Migration

Most migrations are technically simple but operationally sloppy. Teams often change the base URL and key, then assume everything else is identical. That is usually true for the request schema, but it is not always true for everything around it.

The areas worth checking before you switch traffic are:

  • timeout settings in your SDK or HTTP client
  • model allowlists in application config
  • cost dashboards that assume a single provider
  • retry logic that was tuned for one upstream
  • any hardcoded assumptions about response headers or rate limits

If you audit those five areas before flipping production traffic, migration is usually uneventful.

Migration Checklist

Use this checklist if you want the migration to stay boring:

  1. Create a LemonData API key.
  2. Switch base_url or baseURL.
  3. Run one smoke test against /v1/models.
  4. Test one chat completion, one streamed response, and one failure path.
  5. Confirm your logs still capture request IDs and model names.
  6. Check billing after the first few calls to make sure your cost assumptions still hold.
  7. Only then move background jobs and production traffic.

Common Mistakes

Mistake 1: Hardcoding the old model inventory

Some teams validate model IDs against a static list in app config. If you keep that list, the gateway works but your own application rejects valid model names before the request is sent.

Mistake 2: Treating migration as a provider swap

The real benefit is not just leaving OpenAI. The real benefit is moving from a single-provider architecture to a gateway model where you can add Claude, Gemini, DeepSeek, and others without changing the rest of your application again.

Mistake 3: Skipping failure-path tests

A happy-path completion proves the API key works. It does not prove your retry logic, error parsing, or observability still make sense after the move.

If you are shipping a user-facing application rather than just a script, the next two implementation guides to read are the one-key chatbot tutorial and the rate limiting guide.

Common Integration Migration

Cursor

Settings → Models → OpenAI API Key:

  • API Key: sk-lemon-xxx
  • Base URL: https://api.lemondata.cc/v1

LangChain

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4.1",
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

Vercel AI SDK

import { createOpenAI } from '@ai-sdk/openai';

const lemondata = createOpenAI({
  apiKey: 'sk-lemon-xxx',
  baseURL: 'https://api.lemondata.cc/v1',
});

const result = await generateText({
  model: lemondata('gpt-4.1'),
  prompt: 'Hello!',
});

LiteLLM

import litellm

response = litellm.completion(
    model="openai/gpt-4.1",
    messages=[{"role": "user", "content": "Hello!"}],
    api_key="sk-lemon-xxx",
    api_base="https://api.lemondata.cc/v1"
)

Verify Your Migration

Quick sanity check after switching:

curl https://api.lemondata.cc/v1/models \
  -H "Authorization: Bearer sk-lemon-xxx" | head -c 200

If you see a JSON response with model objects, you're good.

FAQ

Will my existing prompts work? Yes. LemonData is fully OpenAI-compatible, so the request and response formats stay the same.

Do I need to change model names? No. gpt-4.1, gpt-4o, and gpt-4.1-mini all work as expected. LemonData also has a three-layer model resolution system: exact match, alias lookup, and fuzzy correction. That means even deprecated names like gpt-4-turbo or typos like gpt4o usually still resolve correctly.

What about streaming? Works identically. SSE format, same chunk structure. For native Anthropic/Gemini protocols, you get each provider's native SSE format (including thinking deltas for extended thinking).

What about function calling / tools? Fully supported. Same schema, same behavior.

What about error handling? LemonData returns OpenAI-compatible errors with additional agent-friendly fields such as retryable, did_you_mean, suggestions, and retry_after. Standard OpenAI SDK error handling still works because those fields are additive.

Can I switch back? Yes. Change the two lines back. There is no proprietary format and no data migration to unwind.

Start here: lemondata.cc/r/devto-migration
Full API documentation: docs.lemondata.cc
Quickstart guide: docs.lemondata.cc/quickstart

Share: