Erori API OpenAI: Ghid Complet de Depanare

Erorile API OpenAI pot opri aplicația ta AI complet. Acest ghid acoperă toate erorile comune și soluțiile lor.

Eroare: 401 Cheie API Invalidă

Simptom:

{
  "error": {
    "message": "Incorrect API key provided: sk-xxxx",
    "type": "invalid_request_error",
    "code": "invalid_api_key"
  }
}

Soluția 1 - Verifică cheia API:

import openai
import os
 
# Verifică dacă cheia e setată
api_key = os.getenv("OPENAI_API_KEY")
print(f"Key starts with: {api_key[:10]}..." if api_key else "No key found!")
 
# Inițializare corectă
client = openai.OpenAI(api_key=api_key)
 
# Testează cheia
try:
    models = client.models.list()
    print("API key is valid!")
except openai.AuthenticationError as e:
    print(f"Invalid API key: {e}")

Soluția 2 - Verifică formatul cheii:

# Formate valide de cheie:
# sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx (standard)
# sk-proj-xxxxxxxx (cheie de proiect)
 
# Greșeli frecvente:
# - Spații extra: "sk-xxx " (spațiu final)
# - Lipsește prefixul sk-
# - Folosirea organization ID în loc de cheie API

Soluția 3 - Regenerează cheia:

Mergi la https://platform.openai.com/api-keys
Creează o nouă cheie secretă
Copiaz-o imediat (se afișează o singură dată)
Actualizează variabila de mediu

Eroare: 429 Rate Limit Depășit

Simptom:

{
  "error": {
    "message": "Rate limit reached for gpt-4 in organization org-xxx",
    "type": "tokens",
    "code": "rate_limit_exceeded"
  }
}

Soluția 1 - Implementează exponential backoff:

import openai
import time
from tenacity import retry, wait_exponential, stop_after_attempt
 
@retry(
    wait=wait_exponential(multiplier=1, min=4, max=60),
    stop=stop_after_attempt(5)
)
def call_openai_with_retry(messages):
    client = openai.OpenAI()
    return client.chat.completions.create(
        model="gpt-4",
        messages=messages
    )
 
# Utilizare
try:
    response = call_openai_with_retry([
        {"role": "user", "content": "Hello!"}
    ])
except openai.RateLimitError as e:
    print(f"Rate limit hit after retries: {e}")

Soluția 2 - Verifică header-ele de rate limit:

import openai
 
client = openai.OpenAI()
 
response = client.chat.completions.with_raw_response.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hi"}]
)
 
# Verifică header-ele
print(f"Requests remaining: {response.headers.get('x-ratelimit-remaining-requests')}")
print(f"Tokens remaining: {response.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Reset time: {response.headers.get('x-ratelimit-reset-requests')}")

Soluția 3 - Solicită creșterea rate limit-ului:

Mergi la https://platform.openai.com/account/limits
Solicită o creștere pe baza tier-ului de utilizare
Adaugă o metodă de plată pentru a trece de la tier-ul gratuit

Eroare: Context Length Exceeded

Simptom:

{
  "error": {
    "message": "This model's maximum context length is 8192 tokens. However, your messages resulted in 12000 tokens.",
    "type": "invalid_request_error",
    "code": "context_length_exceeded"
  }
}

Soluția 1 - Numără și trunchiază token-urile:

import tiktoken
 
def count_tokens(text, model="gpt-4"):
    encoding = tiktoken.encoding_for_model(model)
    return len(encoding.encode(text))
 
def truncate_to_limit(messages, max_tokens=7000, model="gpt-4"):
    encoding = tiktoken.encoding_for_model(model)
    total_tokens = 0
    truncated = []
 
    for msg in messages:
        msg_tokens = len(encoding.encode(msg["content"]))
        if total_tokens + msg_tokens > max_tokens:
            # Trunchiază acest mesaj
            available = max_tokens - total_tokens
            tokens = encoding.encode(msg["content"])[:available]
            msg["content"] = encoding.decode(tokens)
            truncated.append(msg)
            break
        total_tokens += msg_tokens
        truncated.append(msg)
 
    return truncated

Soluția 2 - Folosește un model cu context mai mare:

# Limitele de context per model:
# gpt-3.5-turbo: 16,385 token-uri
# gpt-4: 8,192 token-uri
# gpt-4-turbo: 128,000 token-uri
# gpt-4o: 128,000 token-uri
 
client = openai.OpenAI()
response = client.chat.completions.create(
    model="gpt-4-turbo",  # Context mai mare
    messages=long_conversation
)

Soluția 3 - Implementează sumarizarea conversației:

def summarize_conversation(messages, client):
    """Sumarizează mesajele vechi pentru a economisi spațiu de context."""
    if len(messages) < 10:
        return messages
 
    # Păstrează mesajul sistem și ultimele 5 mesaje
    system_msg = messages[0] if messages[0]["role"] == "system" else None
    recent = messages[-5:]
    old = messages[1:-5] if system_msg else messages[:-5]
 
    # Sumarizează mesajele vechi
    summary_prompt = f"Summarize this conversation briefly:\n{old}"
    summary = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": summary_prompt}]
    ).choices[0].message.content
 
    # Returnează conversația comprimată
    result = []
    if system_msg:
        result.append(system_msg)
    result.append({"role": "system", "content": f"Previous conversation summary: {summary}"})
    result.extend(recent)
 
    return result

Eroare: Timeout / Eroare de Conexiune

Simptom:

openai.APITimeoutError: Request timed out
openai.APIConnectionError: Connection error

Soluția 1 - Crește timeout-ul:

import openai
import httpx
 
client = openai.OpenAI(
    timeout=httpx.Timeout(60.0, connect=10.0)  # 60s total, 10s conectare
)
 
# Sau per request
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hello"}],
    timeout=120.0
)

Soluția 2 - Folosește streaming pentru răspunsuri lungi:

client = openai.OpenAI()
 
stream = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Write a long story"}],
    stream=True
)
 
full_response = ""
for chunk in stream:
    if chunk.choices[0].delta.content:
        content = chunk.choices[0].delta.content
        full_response += content
        print(content, end="", flush=True)

Soluția 3 - Implementează retry cu gestionarea timeout-ului:

import openai
from tenacity import retry, retry_if_exception_type, wait_exponential
 
@retry(
    retry=retry_if_exception_type((
        openai.APITimeoutError,
        openai.APIConnectionError
    )),
    wait=wait_exponential(multiplier=1, min=2, max=30),
    stop=stop_after_attempt(3)
)
def robust_completion(messages):
    client = openai.OpenAI(timeout=60.0)
    return client.chat.completions.create(
        model="gpt-4",
        messages=messages
    )

Eroare: Model Negăsit

Simptom:

{
  "error": {
    "message": "The model 'gpt-5' does not exist",
    "type": "invalid_request_error",
    "code": "model_not_found"
  }
}

Soluție - Folosește nume de model valide:

# Modele valide curente (2026):
VALID_MODELS = {
    "chat": [
        "gpt-4o",           # Cel mai recent, recomandat
        "gpt-4o-mini",      # Mai rapid, mai ieftin
        "gpt-4-turbo",      # Context mare
        "gpt-4",            # GPT-4 original
        "gpt-3.5-turbo",    # Rapid și ieftin
    ],
    "embeddings": [
        "text-embedding-3-large",
        "text-embedding-3-small",
        "text-embedding-ada-002",
    ],
    "images": [
        "dall-e-3",
        "dall-e-2",
    ]
}
 
# Listează modelele disponibile
client = openai.OpenAI()
models = client.models.list()
for model in models:
    print(model.id)

Eroare: Încălcare Politică de Conținut

Simptom:

{
  "error": {
    "message": "Your request was rejected as a result of our safety system",
    "type": "invalid_request_error",
    "code": "content_policy_violation"
  }
}

Soluția 1 - Revizuiește ghidul de conținut:

# OpenAI interzice:
# - Conținut ilegal
# - Hărțuire/violență
# - Conținut pentru adulți
# - Dezinformare
# - Generare de malware/spam
 
# Dacă un caz de utilizare legitim e blocat, încearcă:
# 1. Reformulează cererea
# 2. Adaugă context care explică scopul legitim
# 3. Folosește endpoint-ul de moderation mai întâi

Soluția 2 - Folosește API-ul de Moderation:

client = openai.OpenAI()
 
def check_content(text):
    response = client.moderations.create(input=text)
    result = response.results[0]
 
    if result.flagged:
        print("Content flagged for:")
        for category, flagged in result.categories:
            if flagged:
                print(f"  - {category}")
        return False
    return True
 
# Verifică înainte de trimitere
if check_content(user_input):
    # Sigur de trimis la GPT
    response = client.chat.completions.create(...)

Eroare: Cotă Insuficientă

Simptom:

{
  "error": {
    "message": "You exceeded your current quota, please check your plan and billing details",
    "type": "insufficient_quota",
    "code": "insufficient_quota"
  }
}

Soluție:

Verifică utilizarea: https://platform.openai.com/usage
Adaugă metodă de plată: https://platform.openai.com/account/billing
Setează limite de utilizare pentru a preveni depășirea
Monitorizează costurile cu alerte

# Urmărește utilizarea token-urilor
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hello"}]
)
 
usage = response.usage
print(f"Prompt tokens: {usage.prompt_tokens}")
print(f"Completion tokens: {usage.completion_tokens}")
print(f"Total tokens: {usage.total_tokens}")
 
# Estimează costul (prețurile variază per model)
cost = (usage.prompt_tokens * 0.00003) + (usage.completion_tokens * 0.00006)
print(f"Estimated cost: ${cost:.4f}")

Referință Rapidă: Coduri de Eroare

| Cod | Semnificație | Soluție | |-----|-------------|---------| | 401 | Cheie API invalidă | Regenerează cheia | | 429 | Rate limit | Exponential backoff | | 400 | Request invalid | Verifică parametrii | | 404 | Model negăsit | Folosește un nume valid de model | | 500 | Eroare de server | Retry cu backoff | | 503 | Supraîncărcat | Așteaptă și încearcă din nou |

Checklist pentru Producție

import openai
from tenacity import retry, wait_exponential, stop_after_attempt
 
class RobustOpenAIClient:
    def __init__(self):
        self.client = openai.OpenAI(
            timeout=60.0,
            max_retries=3
        )
 
    @retry(
        wait=wait_exponential(multiplier=1, min=2, max=60),
        stop=stop_after_attempt(5)
    )
    def chat(self, messages, model="gpt-4o"):
        try:
            return self.client.chat.completions.create(
                model=model,
                messages=messages
            )
        except openai.RateLimitError:
            raise  # Lasă tenacity să gestioneze retry-ul
        except openai.APIError as e:
            print(f"API error: {e}")
            raise

Construiești aplicații AI?

Aplicațiile AI de producție necesită gestionare robustă a erorilor și securitate. Echipa noastră se specializează în:

Arhitectură de aplicații AI
Audituri de securitate LLM
Strategii de optimizare a costurilor
Conformitate cu EU AI Act

Obține expertiză AI

Sistemul tau AI e conform cu EU AI Act? Evaluare gratuita de risc - afla in 2 minute →

Erori API OpenAI: Ghid Complet de Depanare

Eroare: 401 Cheie API Invalidă

Eroare: 429 Rate Limit Depășit

Eroare: Context Length Exceeded

Eroare: Timeout / Eroare de Conexiune

Eroare: Model Negăsit

Eroare: Încălcare Politică de Conținut

Eroare: Cotă Insuficientă

Referință Rapidă: Coduri de Eroare

Checklist pentru Producție

Construiești aplicații AI?

Weekly AI Security & Automation Digest

Related Articles

Tutorial ChatGPT API: prima ta aplicatie AI

Chatbot-ul AI nu functioneaza? Probleme comune si cum sa le rezolvi

Erori API Claude: Ghid complet de depanare