Handling responses from OpenAI’s API in Python involves parsing the returned data structure, extracting relevant information, and implementing error handling. When you make a request to the API (e.g., using openai.ChatCompletion.create), the response is a Python dictionary-like object. The primary content you’ll need is typically nested under choices, which contains the generated text or message. For example, after sending a chat request, you can access the model’s output using response.choices[0].message.content. Always check if the response contains valid data before proceeding, as network errors or API limits could result in unexpected responses.
Beyond extracting the main output, you should handle metadata and potential errors. The response includes details like token usage (response.usage.total_tokens), which helps track costs and usage limits. If the API returns an error (e.g., invalid API key or rate limit exceeded), it raises an exception, so wrap your API calls in try-except blocks. For instance, catch openai.error.APIError for server-side issues or openai.error.RateLimitError for rate limits. Additionally, responses for streaming requests behave differently: instead of a single response object, you’ll process chunks iteratively using a loop like for chunk in response: and aggregate the content as it arrives.
To ensure reliability, validate the response structure and implement retries. For example, check if response.choices exists and isn’t empty before accessing its contents. Use libraries like tenacity to add retry logic for transient errors, such as network timeouts. Here’s a basic retry example:
from tenacity import retry, stop_after_attempt, wait_exponential
@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
def safe_api_call():
return openai.ChatCompletion.create(...)
Logging responses and errors is also critical for debugging. Finally, test edge cases, such as empty inputs or max token limits, to ensure your code handles partial or truncated outputs gracefully (e.g., checking response.choices[0].finish_reason for "length" to detect token limits). By structuring your code to anticipate these scenarios, you’ll build more resilient integrations.