OpenAI API Python Tutorial – A Complete Crash Course

pip install openai

export OPENAI_API_KEY="sk-your-key-here"

OPENAI_API_KEY=sk-your-key-here

from dotenv import load_dotenv
load_dotenv()  # Reads .env file and sets environment variables

from openai import OpenAI

client = OpenAI()  # Reads OPENAI_API_KEY from environment
print(client.models.list().data[0].id)

gpt-4o-2024-08-06

An API (Application Programming Interface) is a set of rules that lets different software programs communicate with each other.

Response ID: chatcmpl-abc123xyz
Model used:  gpt-4o-mini-2024-07-18
Finish reason: stop
Prompt tokens:     25
Completion tokens: 22
Total tokens:      47

1. **Personal Finance Tracker** — Build a CLI app that logs expenses, categorizes them, and shows monthly summaries using pandas.

2. **Web Scraper Dashboard** — Create a scraper that collects job listings from multiple sites and displays them in a Streamlit dashboard.

3. **AI Flashcard Generator** — Feed lecture notes to GPT and auto-generate study flashcards with questions and answers.

An API is a set of rules and protocols that allows different software applications to communicate and exchange data with each other.

from openai import OpenAI

client = OpenAI()

stream = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "user", "content": "Explain gradient descent in 3 sentences."}
    ],
    stream=True
)

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

print()  # Newline at the end

Gradient descent is an optimization algorithm that finds the minimum of a function by taking small steps in the direction of steepest decrease. At each step, it calculates the gradient (slope) of the loss function and moves the parameters in the opposite direction. The step size is controlled by the learning rate — too large and it overshoots, too small and it converges slowly.

stream = client.responses.create(
    model="gpt-4o-mini",
    input="Explain gradient descent in 3 sentences.",
    stream=True
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

print()

from openai import OpenAI

client = OpenAI()
messages = [
    {"role": "system", "content": "You are a Python tutor. Keep answers short."}
]

# Turn 1
messages.append({"role": "user", "content": "What is a decorator?"})
response = client.chat.completions.create(model="gpt-4o-mini", messages=messages)
assistant_msg = response.choices[0].message.content
messages.append({"role": "assistant", "content": assistant_msg})
print(f"AI: {assistant_msg}\n")

# Turn 2 — the model remembers Turn 1
messages.append({"role": "user", "content": "Show me an example."})
response = client.chat.completions.create(model="gpt-4o-mini", messages=messages)
assistant_msg = response.choices[0].message.content
print(f"AI: {assistant_msg}")

AI: A decorator is a function that takes another function as input, adds some behavior to it, and returns a modified version — without changing the original function's code.

AI: Here's a simple example:

def log_call(func):
    def wrapper(*args):
        print(f"Calling {func.__name__}")
        return func(*args)
    return wrapper

@log_call
def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))
# Output: Calling greet
#         Hello, Alice!

# Turn 1
response1 = client.responses.create(
    model="gpt-4o-mini",
    instructions="You are a Python tutor. Keep answers short.",
    input="What is a decorator?"
)
print(f"AI: {response1.output_text}\n")

# Turn 2 — pass previous_response_id
response2 = client.responses.create(
    model="gpt-4o-mini",
    previous_response_id=response1.id,
    input="Show me an example."
)
print(f"AI: {response2.output_text}")

{
  type: 'exercise',
  id: 'chatbot-ex1',
  title: 'Exercise 1: Build a Simple Q&A Bot',
  difficulty: 'beginner',
  exerciseType: 'write',
  instructions: 'Complete the function below that takes a user question and a conversation history, calls the OpenAI API, and returns the assistant response as a string. The function should append the user message, make the API call, and return the content.',
  starterCode: 'from openai import OpenAI\n\nclient = OpenAI()\n\ndef ask_bot(question: str, history: list) -> str:\n    """Send a question to GPT and return the response."""\n    # Step 1: Append the user message to history\n    history.append({"role": "user", "content": question})\n    \n    # Step 2: Call the API (use gpt-4o-mini)\n    response = # YOUR CODE HERE\n    \n    # Step 3: Extract and return the assistant message\n    answer = # YOUR CODE HERE\n    \n    # Step 4: Append assistant message to history\n    history.append({"role": "assistant", "content": answer})\n    \n    return answer\n\n# Test it\nhistory = [{"role": "system", "content": "You answer in one sentence."}]\nprint(ask_bot("What is Python?", history))\nprint("DONE")',
  testCases: [
    { id: 'tc1', input: '', expectedOutput: 'DONE', description: 'Function runs and prints DONE' }
  ],
  hints: [
    'Use client.chat.completions.create(model="gpt-4o-mini", messages=history)',
    'Extract the answer with: response.choices[0].message.content'
  ],
  solution: 'from openai import OpenAI\n\nclient = OpenAI()\n\ndef ask_bot(question: str, history: list) -> str:\n    history.append({"role": "user", "content": question})\n    response = client.chat.completions.create(model="gpt-4o-mini", messages=history)\n    answer = response.choices[0].message.content\n    history.append({"role": "assistant", "content": answer})\n    return answer\n\nhistory = [{"role": "system", "content": "You answer in one sentence."}]\nprint(ask_bot("What is Python?", history))\nprint("DONE")',
  solutionExplanation: 'The function adds the user message to the history list, calls the Chat Completions API with the full list, pulls out the reply, adds it back for future turns, and returns it.',
  xpReward: 15,
}

from openai import OpenAI
import json

client = OpenAI()

# Step 1: Define the function schema
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "The city name, e.g. London"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

# Step 2: Our actual function (in real apps, this would call a weather API)
def get_weather(city: str, unit: str = "celsius") -> str:
    # Simulated weather data
    weather_data = {
        "London": {"temp": 15, "condition": "Cloudy"},
        "Tokyo": {"temp": 22, "condition": "Sunny"},
        "New York": {"temp": 18, "condition": "Partly cloudy"},
    }
    data = weather_data.get(city, {"temp": 20, "condition": "Unknown"})
    return json.dumps({"city": city, "temperature": data["temp"], "unit": unit, "condition": data["condition"]})

# Step 3: Send message with tools
messages = [{"role": "user", "content": "What's the weather like in Tokyo?"}]

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages,
    tools=tools
)

# Step 4: Check if the model wants to call a function
tool_call = response.choices[0].message.tool_calls[0]
print(f"Model wants to call: {tool_call.function.name}")
print(f"With arguments: {tool_call.function.arguments}")

Model wants to call: get_weather
With arguments: {"city": "Tokyo", "unit": "celsius"}

# Step 5: Execute the function
args = json.loads(tool_call.function.arguments)
result = get_weather(**args)

# Step 6: Send the result back to the model
messages.append(response.choices[0].message)  # Add the assistant's tool call
messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": result
})

# Step 7: Get the final response
final_response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages,
    tools=tools
)

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

The weather in Tokyo is currently sunny with a temperature of 22°C.

Sentiment:  positive
Confidence: 0.85
Topics:     ['performance', 'display', 'battery life', 'value']
Summary:    A fast laptop with an excellent screen and good value, though battery life is average at 6 hours.

{
  type: 'exercise',
  id: 'structured-ex1',
  title: 'Exercise 2: Extract Movie Information',
  difficulty: 'beginner',
  exerciseType: 'write',
  instructions: 'Define a Pydantic model called MovieInfo with fields: title (str), year (int), genre (str), and rating (float). Then use client.chat.completions.parse() to extract this information from the given movie description. Print the title and year.',
  starterCode: 'from pydantic import BaseModel\nfrom openai import OpenAI\n\nclient = OpenAI()\n\n# Define the Pydantic model\nclass MovieInfo(BaseModel):\n    # YOUR CODE HERE: define title, year, genre, rating fields\n    pass\n\nresponse = client.chat.completions.parse(\n    model="gpt-4o-mini",\n    messages=[\n        {"role": "user", "content": "The Dark Knight (2008) is a superhero thriller rated 9.0 on IMDb."}\n    ],\n    response_format=MovieInfo,\n)\n\nmovie = response.choices[0].message.parsed\nprint(f"{movie.title} ({movie.year})")\nprint("DONE")',
  testCases: [
    { id: 'tc1', input: '', expectedOutput: 'The Dark Knight (2008)', description: 'Should extract title and year' },
    { id: 'tc2', input: '', expectedOutput: 'DONE', description: 'Completes successfully' }
  ],
  hints: [
    'Define fields like: title: str, year: int, genre: str, rating: float',
    'Full model: class MovieInfo(BaseModel):\n    title: str\n    year: int\n    genre: str\n    rating: float'
  ],
  solution: 'from pydantic import BaseModel\nfrom openai import OpenAI\n\nclient = OpenAI()\n\nclass MovieInfo(BaseModel):\n    title: str\n    year: int\n    genre: str\n    rating: float\n\nresponse = client.chat.completions.parse(\n    model="gpt-4o-mini",\n    messages=[\n        {"role": "user", "content": "The Dark Knight (2008) is a superhero thriller rated 9.0 on IMDb."}\n    ],\n    response_format=MovieInfo,\n)\n\nmovie = response.choices[0].message.parsed\nprint(f"{movie.title} ({movie.year})")\nprint("DONE")',
  solutionExplanation: 'We define a Pydantic model with four typed fields. The .parse() method locks the reply to this shape, giving us a typed Python object with clean dot-notation access.',
  xpReward: 15,
}

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What do you see in this image? Be brief."},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg"
                    }
                }
            ]
        }
    ],
    max_tokens=100
)

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

I see an orange tabby cat sitting upright on a wooden surface. The cat has bright green eyes and distinctive striped markings across its fur.

from openai import OpenAI

client = OpenAI()

response = client.images.generate(
    model="dall-e-3",
    prompt="A cozy home office with a standing desk, dual monitors showing Python code, and a cat sleeping on the keyboard",
    size="1024x1024",
    n=1
)

image_url = response.data[0].url
print(f"Image URL: {image_url}")

Image URL: https://oaidalleapiprodscus.blob.core.windows.net/private/...

Cat vs Kitten: 0.8734
Cat vs Stocks: 0.1205

from openai import OpenAI

client = OpenAI()

with open("meeting_recording.mp3", "rb") as audio_file:
    transcript = client.audio.transcriptions.create(
        model="whisper-1",
        file=audio_file
    )

print(transcript.text)

Welcome to today's team standup. Let's start with updates from the backend team...

with open("spanish_podcast.mp3", "rb") as audio_file:
    translation = client.audio.translations.create(
        model="whisper-1",
        file=audio_file
    )

print(translation.text)  # Output is in English regardless of source language

from openai import OpenAI, RateLimitError, APIError, APIConnectionError
import time

client = OpenAI()

def call_with_retry(messages, model="gpt-4o-mini", max_retries=3):
    """Make an API call with automatic retry on transient errors."""
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages
            )
            return response.choices[0].message.content
        except RateLimitError:
            wait_time = 2 ** attempt  # 1s, 2s, 4s
            print(f"Rate limited. Retrying in {wait_time}s...")
            time.sleep(wait_time)
        except (APIError, APIConnectionError) as e:
            wait_time = 2 ** attempt
            print(f"API error: {e}. Retrying in {wait_time}s...")
            time.sleep(wait_time)

    raise Exception(f"Failed after {max_retries} retries")

# Usage
result = call_with_retry([{"role": "user", "content": "Hello!"}])
print(result)

Hello! How can I help you today?

import tiktoken

def count_tokens(text: str, model: str = "gpt-4o-mini") -> int:
    """Count the number of tokens in a text string."""
    encoding = tiktoken.encoding_for_model(model)
    return len(encoding.encode(text))

# Example
text = "The quick brown fox jumps over the lazy dog."
tokens = count_tokens(text)
print(f"Text: '{text}'")
print(f"Tokens: {tokens}")
print(f"Estimated cost (GPT-4o-mini input): ${tokens * 0.15 / 1_000_000:.8f}")

Text: 'The quick brown fox jumps over the lazy dog.'
Tokens: 10
Estimated cost (GPT-4o-mini input): $0.00000150

{
  type: 'exercise',
  id: 'tokens-ex1',
  title: 'Exercise 3: Token-Aware Message Trimmer',
  difficulty: 'intermediate',
  exerciseType: 'write',
  instructions: 'Write a function called `trim_messages` that takes a list of messages and a max_tokens limit. It should remove the OLDEST user/assistant messages (keep the system message) until the total token count is under the limit. Use tiktoken to count tokens. Print the number of messages before and after trimming.',
  starterCode: 'import tiktoken\n\ndef count_message_tokens(messages: list, model: str = "gpt-4o-mini") -> int:\n    """Count total tokens across all messages."""\n    encoding = tiktoken.encoding_for_model(model)\n    total = 0\n    for msg in messages:\n        total += len(encoding.encode(msg["content"])) + 4  # 4 tokens overhead per message\n    return total\n\ndef trim_messages(messages: list, max_tokens: int = 100) -> list:\n    """Remove oldest non-system messages until under max_tokens."""\n    # YOUR CODE HERE\n    pass\n\n# Test it\nmessages = [\n    {"role": "system", "content": "You are helpful."},\n    {"role": "user", "content": "Tell me about Python."},\n    {"role": "assistant", "content": "Python is a popular programming language known for its readability."},\n    {"role": "user", "content": "What about Java?"},\n    {"role": "assistant", "content": "Java is a statically typed language widely used in enterprise applications."},\n    {"role": "user", "content": "Compare them."},\n]\n\nbefore = len(messages)\ntrimmed = trim_messages(messages, max_tokens=60)\nafter = len(trimmed)\nprint(f"Before: {before}, After: {after}")\nprint("DONE")',
  testCases: [
    { id: 'tc1', input: '', expectedOutput: 'DONE', description: 'Function runs successfully' }
  ],
  hints: [
    'Separate system messages from the rest. Loop and remove from the start of non-system messages while total tokens exceed max_tokens.',
    'system_msgs = [m for m in messages if m["role"] == "system"]\nother_msgs = [m for m in messages if m["role"] != "system"]\nwhile count_message_tokens(system_msgs + other_msgs) > max_tokens and other_msgs:\n    other_msgs.pop(0)\nreturn system_msgs + other_msgs'
  ],
  solution: 'import tiktoken\n\ndef count_message_tokens(messages, model="gpt-4o-mini"):\n    encoding = tiktoken.encoding_for_model(model)\n    total = 0\n    for msg in messages:\n        total += len(encoding.encode(msg["content"])) + 4\n    return total\n\ndef trim_messages(messages, max_tokens=100):\n    system_msgs = [m for m in messages if m["role"] == "system"]\n    other_msgs = [m for m in messages if m["role"] != "system"]\n    while count_message_tokens(system_msgs + other_msgs) > max_tokens and other_msgs:\n        other_msgs.pop(0)\n    return system_msgs + other_msgs\n\nmessages = [\n    {"role": "system", "content": "You are helpful."},\n    {"role": "user", "content": "Tell me about Python."},\n    {"role": "assistant", "content": "Python is a popular programming language known for its readability."},\n    {"role": "user", "content": "What about Java?"},\n    {"role": "assistant", "content": "Java is a statically typed language widely used in enterprise applications."},\n    {"role": "user", "content": "Compare them."},\n]\n\nbefore = len(messages)\ntrimmed = trim_messages(messages, max_tokens=60)\nafter = len(trimmed)\nprint(f"Before: {before}, After: {after}")\nprint("DONE")',
  solutionExplanation: 'We split system messages (always kept) from chat messages. Then we pop the oldest chat messages one at a time until tokens drop below the cap. This keeps the freshest context while staying on budget.',
  xpReward: 20,
}

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

async def summarize(text: str) -> str:
    """Summarize a text using the async client."""
    response = await async_client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "Summarize in one sentence."},
            {"role": "user", "content": text}
        ]
    )
    return response.choices[0].message.content

async def main():
    texts = [
        "Python was created by Guido van Rossum and first released in 1991.",
        "JavaScript is the language of the web browser.",
        "Rust focuses on memory safety without garbage collection.",
        "Go was designed at Google for concurrent systems programming.",
        "TypeScript adds static types to JavaScript.",
    ]

    # Process all 5 in parallel
    summaries = await asyncio.gather(*[summarize(t) for t in texts])

    for text, summary in zip(texts, summaries):
        print(f"Original: {text[:50]}...")
        print(f"Summary:  {summary}\n")

asyncio.run(main())

Original: Python was created by Guido van Rossum and first ...
Summary:  Python is a programming language created by Guido van Rossum, first released in 1991.

Original: JavaScript is the language of the web browser....
Summary:  JavaScript is the primary programming language used in web browsers.

Original: Rust focuses on memory safety without garbage col...
Summary:  Rust is a programming language that ensures memory safety without relying on garbage collection.

Original: Go was designed at Google for concurrent systems p...
Summary:  Go is a Google-designed language built for concurrent systems programming.

Original: TypeScript adds static types to JavaScript....
Summary:  TypeScript is a superset of JavaScript that introduces static typing.

from openai import OpenAI
from pydantic import BaseModel
import json

client = OpenAI()

# Output schema — what our report looks like
class ResearchReport(BaseModel):
    topic: str
    summary: str
    key_findings: list[str]
    sources_used: list[str]
    difficulty_level: str  # "beginner", "intermediate", "advanced"

# Tool definition — our "search" function
tools = [
    {
        "type": "function",
        "function": {
            "name": "search_knowledge_base",
            "description": "Search for information about a topic in the knowledge base",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "The search query"
                    }
                },
                "required": ["query"]
            }
        }
    }
]

def search_knowledge_base(query: str) -> str:
    """Simulated knowledge base search."""
    knowledge = {
        "neural networks": "Neural networks are computing systems inspired by biological neural networks. They consist of layers of interconnected nodes. Key types: CNNs for images, RNNs for sequences, Transformers for attention-based processing.",
        "transformers": "Transformers use self-attention to process sequences in parallel. Introduced in 'Attention Is All You Need' (2017). Foundation of GPT, BERT, and all modern LLMs.",
        "attention mechanism": "Attention lets the model focus on relevant parts of the input. Self-attention computes relationships between all positions in a sequence. Multi-head attention runs multiple attention operations in parallel.",
    }
    for key, value in knowledge.items():
        if key in query.lower():
            return json.dumps({"results": [value], "source": f"knowledge_base/{key}"})
    return json.dumps({"results": ["No specific information found."], "source": "knowledge_base/general"})

def run_research(topic: str) -> ResearchReport:
    """Run the research assistant pipeline."""
    messages = [
        {"role": "system", "content": "You are a research assistant. Search the knowledge base to gather information, then produce a structured report."},
        {"role": "user", "content": f"Research this topic: {topic}"}
    ]

    # Let the model search (up to 3 searches)
    for _ in range(3):
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=tools
        )

        if response.choices[0].finish_reason == "stop":
            break  # Model is done searching

        if response.choices[0].message.tool_calls:
            messages.append(response.choices[0].message)
            for tool_call in response.choices[0].message.tool_calls:
                args = json.loads(tool_call.function.arguments)
                result = search_knowledge_base(**args)
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": result
                })

    # Now get the structured report
    report_response = client.chat.completions.parse(
        model="gpt-4o-mini",
        messages=messages + [
            {"role": "user", "content": "Now produce the structured research report based on what you found."}
        ],
        response_format=ResearchReport,
    )

    return report_response.choices[0].message.parsed

report = run_research("How do transformers and attention mechanisms work?")

print(f"Topic: {report.topic}")
print(f"Difficulty: {report.difficulty_level}")
print(f"\nSummary: {report.summary}")
print(f"\nKey Findings:")
for i, finding in enumerate(report.key_findings, 1):
    print(f"  {i}. {finding}")
print(f"\nSources: {report.sources_used}")

Topic: Transformers and Attention Mechanisms
Difficulty: intermediate

Summary: Transformers are a neural network architecture that uses self-attention mechanisms to process sequences in parallel, enabling powerful language models like GPT and BERT.

Key Findings:
  1. Transformers process sequences in parallel using self-attention, unlike RNNs which process sequentially.
  2. Self-attention computes relationships between all positions in a sequence simultaneously.
  3. Multi-head attention runs multiple attention operations in parallel for richer representations.
  4. Introduced in the 2017 paper 'Attention Is All You Need', transformers are the foundation of all modern LLMs.

Sources: ['knowledge_base/transformers', 'knowledge_base/attention mechanism']

client = OpenAI(api_key="sk-abc123...")  # Key exposed in source code!

from openai import OpenAI
client = OpenAI()  # Reads OPENAI_API_KEY from environment automatically

# Fires 100 requests with no throttling
for item in items:
    response = client.chat.completions.create(model="gpt-4o-mini", messages=[...])

import time
from openai import RateLimitError

for item in items:
    try:
        response = client.chat.completions.create(model="gpt-4o-mini", messages=[...])
    except RateLimitError:
        time.sleep(2)  # Wait and retry

# History grows forever — eventually exceeds context window
messages.append({"role": "user", "content": user_input})
response = client.chat.completions.create(model="gpt-4o-mini", messages=messages)

# Trim old messages to stay within budget
if count_tokens(messages) > 100000:
    messages = [messages[0]] + messages[-10:]  # Keep system message + last 10 turns

# Old completions API — deprecated
response = openai.Completion.create(model="text-davinci-003", prompt="Hello")

# Modern SDK with Chat Completions or Responses API
client = OpenAI()
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Hello"}]
)

import json

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Return a JSON with name and age"}]
)
data = json.loads(response.choices[0].message.content)  # Fragile! May fail

from pydantic import BaseModel

class Person(BaseModel):
    name: str
    age: int

response = client.chat.completions.parse(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Return info for John, age 30"}],
    response_format=Person
)
person = response.choices[0].message.parsed  # Guaranteed to match schema