How to Integrate the OpenAI API in Your Application

Integrating the OpenAI API takes 5 minutes: get an API key, install the SDK, and make your first request. The API supports chat completions, embeddings, image generation, and more across Python, Node.js, and any language via REST.

Quick Start (Python)

from openai import OpenAI

client = OpenAI()  # Uses OPENAI_API_KEY env var

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}]
)

print(response.choices[0].message.content)

Step-by-Step Integration

Step 1: Get Your API Key

1. Go to platform.openai.com
2. Sign up or log in
3. Navigate to API Keys
4. Create new secret key
5. Copy and store securely

⚠️ Never commit API keys to version control

Step 2: Install the SDK

Python:

pip install openai

Node.js:

npm install openai

Step 3: Set Up Authentication

Environment variable (recommended):

export OPENAI_API_KEY="sk-..."

In code:

from openai import OpenAI
client = OpenAI(api_key="sk-...")

Step 4: Make Your First Request

Chat Completion:

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is RAG?"}
    ],
    temperature=0.7,
    max_tokens=500
)

answer = response.choices[0].message.content

Streaming (for real-time output):

stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Write a poem"}],
    stream=True
)

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

Step 5: Handle Errors

from openai import OpenAI, APIError, RateLimitError

client = OpenAI()

try:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": "Hello"}]
    )
except RateLimitError:
    print("Rate limited - wait and retry")
except APIError as e:
    print(f"API error: {e}")

Common API Endpoints

Chat Completions (Most Common)

client.chat.completions.create(
    model="gpt-4o",  # or gpt-4o-mini, gpt-4-turbo
    messages=[...],
    temperature=0.7,
    max_tokens=1000
)

Embeddings

response = client.embeddings.create(
    model="text-embedding-3-small",
    input="Text to embed"
)
embedding = response.data[0].embedding

Image Generation

response = client.images.generate(
    model="dall-e-3",
    prompt="A sunset over mountains",
    size="1024x1024",
    quality="hd"
)
image_url = response.data[0].url

Vision (Image Analysis)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What's in this image?"},
            {"type": "image_url", "image_url": {"url": "https://..."}}
        ]
    }]
)

Node.js Example

import OpenAI from 'openai';

const openai = new OpenAI();

async function chat(message) {
    const response = await openai.chat.completions.create({
        model: 'gpt-4o',
        messages: [{ role: 'user', content: message }]
    });
    return response.choices[0].message.content;
}

REST API (Any Language)

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

Pricing (March 2026)

Model	Input (1M tokens)	Output (1M tokens)
GPT-4o	$2.50	$10.00
GPT-4o-mini	$0.15	$0.60
GPT-4-turbo	$10.00	$30.00

Best Practices

1. Use environment variables for API keys
2. Implement retry logic for rate limits
3. Set max_tokens to control costs
4. Use streaming for better UX
5. Cache responses when appropriate
6. Monitor usage via OpenAI dashboard

Complete Example: Q&A Bot

from openai import OpenAI

client = OpenAI()

def ask_question(question, context=""):
    messages = [
        {"role": "system", "content": "Answer questions concisely."}
    ]
    if context:
        messages.append({"role": "system", "content": f"Context: {context}"})
    messages.append({"role": "user", "content": question})
    
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages,
        temperature=0.3
    )
    return response.choices[0].message.content

# Usage
answer = ask_question("What is the capital of France?")
print(answer)  # "Paris"

Related Questions

• Best AI coding assistants 2026
• How to build an AI agent
• OpenAI API pricing explained

---

Last verified: 2026-03-06