How to Migrate from OpenAI to DeepSeek in 10 Minutes (Complete Guide)

The best thing about switching from OpenAI to DeepSeek? You barely need to change any code.

DeepSeek exposes an OpenAI-compatible API, which means your existing OpenAI SDK calls work with just two modifications:

1. Change base_url to https://global-apis.com/v1
2. Update api_key to your Global API key

That's it. No rewriting prompts, no learning new SDKs, no restructuring your codebase. This guide covers every major language and framework — with copy-paste-ready code for each.

TL;DR: If your code uses the OpenAI Python/Node SDK, migration is a 2-line change. See your language section below, make the change, and your costs drop 90-97% instantly.

---

Prerequisites

• An existing project using the OpenAI API (Python, JavaScript, Java, Go, cURL, or any language with an OpenAI-compatible SDK)
• A Global API account — free, takes 30 seconds, no credit card
• Your API key from the Global API dashboard — a 32-character hex string

---

Step 1: Get Your Global API Key

1. Go to global-apis.com/register
2. Sign up with email and password (no credit card needed)
3. Go to Dashboard → copy your API key
4. Your key looks like: a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4 (32-character hex)
5. Store it securely — treat it like a password. Use environment variables in production.

---

Step 2: Update Your Code by Language

Python (openai library)

Before:

from openai import OpenAI

client = OpenAI(api_key="sk-your-openai-key")

After:

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["GLOBAL_API_KEY"],     # Your 32-char hex key
    base_url="https://global-apis.com/v1"      # Global API endpoint
)
# Everything else stays identical!

Full working example (migrated):

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["GLOBAL_API_KEY"],
    base_url="https://global-apis.com/v1"
)

# Chat completion — identical API
response = client.chat.completions.create(
    model="deepseek-chat",                      # Was: "gpt-4o"
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain the difference between REST and GraphQL."}
    ],
    temperature=0.7,
    max_tokens=512,
    stream=False
)

print(response.choices[0].message.content)
print(f"Tokens: {response.usage.prompt_tokens} in / {response.usage.completion_tokens} out")

JavaScript / TypeScript (openai-node)

Before:

import OpenAI from 'openai';

const client = new OpenAI({
    apiKey: process.env.OPENAI_API_KEY
});

After:

import OpenAI from 'openai';

const client = new OpenAI({
    apiKey: process.env.GLOBAL_API_KEY,         // Your 32-char hex key
    baseURL: 'https://global-apis.com/v1'       // Global API endpoint
});

Full working example (migrated):

import OpenAI from 'openai';

const client = new OpenAI({
    apiKey: process.env.GLOBAL_API_KEY,
    baseURL: 'https://global-apis.com/v1'
});

async function main() {
    const response = await client.chat.completions.create({
        model: 'deepseek-chat',                 // Was: 'gpt-4o'
        messages: [
            { role: 'system', content: 'You are a concise technical writer.' },
            { role: 'user', content: 'Write a README template for a Node.js project.' }
        ],
        temperature: 0.7,
        max_tokens: 1024
    });

    console.log(response.choices[0].message.content);
    console.log(`Tokens: ${response.usage.prompt_tokens} in / ${response.usage.completion_tokens} out`);
}

main().catch(console.error);

cURL

Before:

curl https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer sk-your-openai-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "messages": [{"role": "user", "content": "Hello, world!"}]
  }'

After:

curl https://global-apis.com/v1/chat/completions \
  -H "Authorization: Bearer your-global-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-chat",
    "messages": [{"role": "user", "content": "Hello, world!"}]
  }'

Java (openai-java)

Before:

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;

OpenAIClient client = OpenAIOkHttpClient.builder()
    .apiKey("sk-your-openai-key")
    .build();

After:

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;

OpenAIClient client = OpenAIOkHttpClient.builder()
    .apiKey(System.getenv("GLOBAL_API_KEY"))
    .baseUrl("https://global-apis.com/v1")      // New base URL
    .build();

ChatCompletion completion = client.chat().completions().create(
    ChatCompletionCreateParams.builder()
        .model("deepseek-chat")                  // Was: "gpt-4o"
        .addUserMessage("Explain Java generics.")
        .maxTokens(512)
        .build()
);

System.out.println(completion.choices().get(0).message().content().get());

Go (go-openai / sashabaranov)

Before:

import "github.com/sashabaranov/go-openai"

client := openai.NewClient("sk-your-openai-key")

After:

import (
    "github.com/sashabaranov/go-openai"
    "os"
)

config := openai.DefaultConfig(os.Getenv("GLOBAL_API_KEY"))
config.BaseURL = "https://global-apis.com/v1"       // New base URL
client := openai.NewClientWithConfig(config)

resp, err := client.CreateChatCompletion(
    context.Background(),
    openai.ChatCompletionRequest{
        Model: "deepseek-chat",                      // Was: openai.GPT4o
        Messages: []openai.ChatCompletionMessage{
            {Role: openai.ChatMessageRoleUser, Content: "Explain Go interfaces."},
        },
        MaxTokens: 512,
    },
)

if err == nil {
    fmt.Println(resp.Choices[0].Message.Content)
}

LangChain (Python)

Before:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o", api_key="sk-...")

After:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="deepseek-chat",                          # Was: "gpt-4o"
    api_key="your-global-api-key",
    base_url="https://global-apis.com/v1"           # New base URL
)

# All your chains, agents, and tools work unchanged
result = llm.invoke("Explain prompt engineering best practices.")
print(result.content)

LlamaIndex (Python)

Before:

from llama_index.llms.openai import OpenAI

llm = OpenAI(model="gpt-4o", api_key="sk-...")

After:

from llama_index.llms.openai import OpenAI

llm = OpenAI(
    model="deepseek-chat",                          # Was: "gpt-4o"
    api_key="your-global-api-key",
    api_base="https://global-apis.com/v1"           # New base URL
)

# RAG pipelines, query engines, agents — all work unchanged

---

Step 3: Update Model Names

| OpenAI Model | DeepSeek Equivalent (via Global API) | Notes | |-------------|--------------------------------------|-------| | gpt-4o | deepseek-chat | V4 Flash — 97% cheaper, 95% of the quality | | gpt-4-turbo | deepseek-chat | V4 Flash is faster and cheaper | | gpt-4o-mini | deepseek-chat | V4 Flash actually benchmarks higher | | gpt-3.5-turbo | deepseek-chat | V4 Flash is dramatically better | | o1 / o3-mini | deepseek-reasoner | Chain-of-thought reasoning, 96% cheaper than o1 | | text-embedding-3-small | Check Global API docs | Embedding model availability varies |

Pro tip: Use environment variables for model names too:

import os
MODEL = os.getenv("LLM_MODEL", "deepseek-chat")  # Easy to switch back

---

Step 4: Test Everything

Run your existing test suite. Since the API format is identical, most tests should pass without modification.

Quick Validation Script

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["GLOBAL_API_KEY"],
    base_url="https://global-apis.com/v1"
)

# Test 1: Basic chat
response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[{"role": "user", "content": "Say 'migration successful' in one word."}],
    max_tokens=10
)
assert "successful" in response.choices[0].message.content.lower()
print("✅ Basic chat: OK")

# Test 2: Streaming
stream = client.chat.completions.create(
    model="deepseek-chat",
    messages=[{"role": "user", "content": "Count from 1 to 3."}],
    stream=True
)
chunks = [c for c in stream if c.choices[0].delta.content]
assert len(chunks) > 0
print(f"✅ Streaming: OK ({len(chunks)} chunks)")

# Test 3: Function calling
tools = [{
    "type": "function",
    "function": {
        "name": "get_time",
        "description": "Get current time",
        "parameters": {"type": "object", "properties": {}}
    }
}]
response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[{"role": "user", "content": "What time is it?"}],
    tools=tools,
    tool_choice="auto"
)
assert response.choices[0].message.tool_calls is not None
print("✅ Function calling: OK")

# Test 4: JSON mode
response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[{"role": "user", "content": "Return JSON: {\"status\": \"ok\"}"}],
    response_format={"type": "json_object"}
)
import json
data = json.loads(response.choices[0].message.content)
assert "status" in data
print("✅ JSON mode: OK")

print("\n🎉 All tests passed! Migration complete.")

---

Step 5: Handle Edge Cases

Streaming Responses

Streaming works identically — just add stream=True:

stream = client.chat.completions.create(
    model="deepseek-chat",
    messages=[{"role": "user", "content": "Write a haiku about programming."}],
    stream=True,
    max_tokens=100
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Function Calling / Tool Use

Function calling is fully supported. Define tools exactly as you would with OpenAI:

tools = [
    {
        "type": "function",
        "function": {
            "name": "search_knowledge_base",
            "description": "Search the company knowledge base",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search query"},
                    "max_results": {"type": "integer", "default": 5}
                },
                "required": ["query"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[{"role": "user", "content": "Find docs about our refund policy."}],
    tools=tools,
    tool_choice="auto"
)

# Process tool calls exactly as with OpenAI
if response.choices[0].message.tool_calls:
    for tool_call in response.choices[0].message.tool_calls:
        fn_name = tool_call.function.name
        fn_args = json.loads(tool_call.function.arguments)
        # Execute your function...

Error Handling & Retries

Use the same retry pattern you'd use with OpenAI:

import time
from openai import RateLimitError, APITimeoutError, APIConnectionError

def call_with_retry(messages, max_retries=3, **kwargs):
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="deepseek-chat",
                messages=messages,
                **kwargs
            )
            return response.choices[0].message.content
        except RateLimitError:
            if attempt == max_retries - 1: raise
            wait = (2 ** attempt) + random.uniform(0, 1)
            print(f"Rate limited. Retrying in {wait:.1f}s...")
            time.sleep(wait)
        except (APITimeoutError, APIConnectionError) as e:
            if attempt == max_retries - 1: raise
            wait = (2 ** attempt) + random.uniform(0, 1)
            print(f"Connection error: {e}. Retrying in {wait:.1f}s...")
            time.sleep(wait)

---

A/B Testing Strategy: Validate Before Full Cutover

Before switching 100% of traffic, run both providers in parallel:

import os
import random
from openai import OpenAI

# Two clients — one for each provider
openai_client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

deepseek_client = OpenAI(
    api_key=os.environ["GLOBAL_API_KEY"],
    base_url="https://global-apis.com/v1"
)

def ab_test_completion(prompt: str, split: float = 0.5):
    """
    Route split% of traffic to DeepSeek.
    Start at 10%, increase as confidence grows.
    """
    use_deepseek = random.random() < split
    
    client = deepseek_client if use_deepseek else openai_client
    model = "deepseek-chat" if use_deepseek else "gpt-4o"
    
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=512
    )
    
    return {
        "content": response.choices[0].message.content,
        "provider": "deepseek" if use_deepseek else "openai",
        "usage": response.usage
    }

# Start at 10% DeepSeek, monitor for a week, then increase
result = ab_test_completion("Explain machine learning.", split=0.1)
print(f"Provider: {result['provider']}")
print(f"Response: {result['content'][:200]}...")

A/B testing progression:

1. Week 1: 10% DeepSeek — validate quality and latency
2. Week 2: 50% DeepSeek — stress test at higher volume
3. Week 3: 90% DeepSeek — near-full cutover, keep GPT-4o as fallback
4. Week 4: 100% DeepSeek — full migration, remove OpenAI dependency

---

Common Migration Issues & Solutions

| Issue | Likely Cause | Solution | |-------|-------------|----------| | Model not found | Wrong model name | Use deepseek-chat not gpt-4o. Check docs for current model IDs | | 401 Unauthorized | Invalid API key | Verify your key in the dashboard. Should be 32-char hex | | 429 Too Many Requests | Rate limit hit | Implement exponential backoff. Paid plans have higher limits | | Response style slightly different | Model differences | DeepSeek tends to be more concise. Adjust temperature if needed | | Vision/image input not working | Model capability | Check model supports vision. Use specific vision-capable models | | Higher first-request latency | Cold start | First request may be slower (~2s). Subsequent requests are fast (~0.5s) | | max_tokens limit different | Model-specific limits | DeepSeek V4 Flash max output: 8,192 tokens | | Embedding dimensions differ | Model differences | Check embedding model specs. Dimensions may not match OpenAI's |

---

Cost Comparison: Before vs After

Track your savings from day one:

from dataclasses import dataclass
from typing import Literal

@dataclass
class MigrationTracker:
    """Track costs across OpenAI and DeepSeek during migration."""
    openai_cost: float = 0.0
    deepseek_cost: float = 0.0
    openai_requests: int = 0
    deepseek_requests: int = 0
    
    GPT4O_PRICE = {"input": 2.50, "output": 10.00}      # Per 1M tokens
    DEEPSEEK_PRICE = {"input": 0.14, "output": 0.28}    # Per 1M tokens
    
    def record(self, provider: Literal["openai", "deepseek"], usage):
        prices = self.GPT4O_PRICE if provider == "openai" else self.DEEPSEEK_PRICE
        cost = ((usage.prompt_tokens / 1_000_000) * prices["input"] +
                (usage.completion_tokens / 1_000_000) * prices["output"])
        
        if provider == "openai":
            self.openai_cost += cost
            self.openai_requests += 1
        else:
            self.deepseek_cost += cost
            self.deepseek_requests += 1
    
    def report(self):
        total_openai_equivalent = ((self.deepseek_requests * 0.001) * 10.0)  # Rough estimate
        savings = total_openai_equivalent - self.deepseek_cost
        
        print(f"""
╔══════════════════════════════════════╗
║       Migration Cost Report         ║
╠══════════════════════════════════════╣
║ OpenAI requests:    {self.openai_requests:>12}       ║
║ DeepSeek requests:  {self.deepseek_requests:>12}       ║
║ OpenAI cost:        ${self.openai_cost:>12.4f}       ║
║ DeepSeek cost:      ${self.deepseek_cost:>12.4f}       ║
║ Est. savings:       ${savings:>12.4f}       ║
╚══════════════════════════════════════╝
""")

tracker = MigrationTracker()

---

Rollback Plan

If anything doesn't work as expected, rolling back is trivial:

# Just switch back to OpenAI
client = OpenAI(
    api_key=os.environ["OPENAI_API_KEY"]   # Original OpenAI key
    # No base_url → defaults to api.openai.com
)

Keep your OpenAI credentials active during the transition period (1-2 weeks minimum). This gives you an instant rollback path if needed.

---

What About Cost Monitoring After Migration?

After migration, track your savings with Global API's dashboard or programmatically:

# Check credit balance anytime
import requests

response = requests.get(
    "https://global-apis.com/api/user/credits",
    headers={"Authorization": f"Bearer {os.environ['GLOBAL_API_KEY']}"}
)
print(f"Remaining credits: {response.json()['credits']}")

---

You're Done! ✅

In under 10 minutes, you've:

1. Created a Global API account (free)
2. Changed 2 lines of code (base_url + api_key)
3. Updated model names (gpt-4o → deepseek-chat)
4. Validated with test suite
5. Set up A/B testing or cost tracking

Your code works identically. Your costs are down 90-97%. Your API key now gives you access to 100+ models through one endpoint.

---

Questions? Check the Global API docs or reach out through the dashboard. We've helped hundreds of teams migrate — if you hit a snag, we're happy to help.

Migration difficulty: Beginner · Time required: 5-10 minutes · Risk: Very Low (easy rollback)

Related Articles

• How to Use DeepSeek API with Python: Complete Guide
• Why I Switched from GPT-4 to DeepSeek
• OpenAI API Alternative 2026: Top 10 Cheapest Options
• DeepSeek API Pricing Guide: Save Up to 74% vs OpenAI
• AI API Cost Comparison 2026