Building your first app with the OpenAI API is one of the most satisfying experiences in modern software development. Within an hour, you can have a working program that takes user input, sends it to a state-of-the-art AI model, and returns a useful response. That’s genuinely remarkable, and the barrier to entry has never been lower.
This tutorial walks through everything from creating your API key to building a simple but functional chatbot — with all the code you need and explanations of what’s actually happening at each step. No prior experience with AI APIs required, but you should have basic Python knowledge (variables, functions, loops).
Prerequisites
Before we start, you’ll need:
- Python 3.8 or higher installed
- A text editor (VS Code recommended)
- An OpenAI account (free to create; you’ll need to add payment info for API access)
Step 1: Set Up Your OpenAI Account and Get an API Key
Go to platform.openai.com and sign in or create an account. Navigate to the API Keys section (under your profile settings) and click “Create new secret key.”
Critical security practice: Treat your API key like a password. Never paste it directly into code, never commit it to git, and never share it publicly.
The right way to handle API keys is through environment variables. On Mac/Linux, add this to your terminal session or shell configuration file:
export OPENAI_API_KEY="your-api-key-here"
On Windows (Command Prompt):
setx OPENAI_API_KEY "your-api-key-here"
Step 2: Set Up Your Python Environment
Create a project folder and set up a virtual environment:
mkdir my-first-ai-app
cd my-first-ai-app
python -m venv venv
source venv/bin/activate # Mac/Linux
# venv\Scripts\activate # Windows
pip install openai
Step 3: Your First API Call
Create a file called first_call.py:
from openai import OpenAI
# The client automatically reads OPENAI_API_KEY from your environment
client = OpenAI()
response = client.chat.completions.create(
model="gpt-4o-mini", # cheaper model, good for testing
messages=[
{"role": "user", "content": "What is the capital of France?"}
]
)
# The response content is nested inside the response object
print(response.choices[0].message.content)
Run it:
python first_call.py
You should see: The capital of France is Paris.
Congratulations — you just made your first API call. Let’s understand what happened.
Understanding the Request Structure
The messages parameter is the most important part of the API call. It’s a list of message objects, each with a role and content:
"role": "user"— a message from the human user"role": "assistant"— a message from the AI"role": "system"— instructions that define how the AI should behave
The API is stateless — it doesn’t remember previous conversations. If you want a multi-turn conversation, you need to include all previous messages in each request:
messages = [
{"role": "system", "content": "You are a helpful cooking assistant."},
{"role": "user", "content": "What should I make for dinner?"},
{"role": "assistant", "content": "How about pasta? What ingredients do you have?"},
{"role": "user", "content": "I have chicken, tomatoes, and garlic."}
]
Understanding Tokens and Costs
Tokens are how the API measures and charges for usage. A token is roughly 4 characters or 0.75 words in English. “Hello, how are you?” is about 5 tokens.
You pay for both input tokens (your messages) and output tokens (the AI’s response). The costs vary by model:
- gpt-4o-mini: Very cheap — good for development, testing, and high-volume applications
- gpt-4o: More capable, more expensive — good for production applications where quality matters
- gpt-4o-mini is a great default for learning and prototyping
You can check usage in your OpenAI dashboard at platform.openai.com/usage.
Step 4: Build a Simple Chatbot
Now let’s build something more interesting — a chatbot you can actually have a conversation with in your terminal.
Create chatbot.py:
from openai import OpenAI
client = OpenAI()
def chat(conversation_history, user_message):
"""Add a user message and get a response."""
conversation_history.append({
"role": "user",
"content": user_message
})
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=conversation_history,
max_tokens=500 # limit response length
)
assistant_message = response.choices[0].message.content
# Add the assistant's response to history for next turn
conversation_history.append({
"role": "assistant",
"content": assistant_message
})
return assistant_message
def main():
# System message sets the AI's persona
conversation_history = [
{
"role": "system",
"content": "You are a helpful assistant that gives concise, practical answers."
}
]
print("AI Chatbot ready. Type 'quit' to exit.\n")
while True:
user_input = input("You: ").strip()
if user_input.lower() in ['quit', 'exit', 'q']:
print("Goodbye!")
break
if not user_input:
continue
response = chat(conversation_history, user_input)
print(f"\nAssistant: {response}\n")
if __name__ == "__main__":
main()
Run it:
python chatbot.py
This is a working, multi-turn chatbot. It maintains conversation context by passing the full history with each request.
Step 5: Adding Streaming Responses
For a better user experience, you can stream the response as it’s generated rather than waiting for the complete response:
from openai import OpenAI
client = OpenAI()
stream = client.chat.completions.create(
model="gpt-4o-mini",
messages=[{"role": "user", "content": "Tell me three tips for writing better code."}],
stream=True # enable streaming
)
print("Response: ", end="", flush=True)
for chunk in stream:
if chunk.choices[0].delta.content is not None:
print(chunk.choices[0].delta.content, end="", flush=True)
print() # new line when done
With streaming, users see text appearing word by word — much more responsive feeling than waiting 10 seconds for a complete response.
Step 6: A Real Project — Email Subject Line Generator
Here’s a practical mini-project: a tool that generates email subject lines from email body text.
Create email_subject_generator.py:
from openai import OpenAI
client = OpenAI()
def generate_subject_lines(email_body: str, num_options: int = 5) -> list[str]:
"""Generate email subject line options for a given email body."""
prompt = f"""Generate {num_options} compelling email subject lines for the following email body.
Email Body:
{email_body}
Return only the subject lines, one per line, without numbering or additional text."""
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": "You are an expert email marketer who writes compelling, specific subject lines."
},
{
"role": "user",
"content": prompt
}
],
max_tokens=300
)
# Split the response into individual lines, filter empty lines
subject_lines = [
line.strip()
for line in response.choices[0].message.content.split('\n')
if line.strip()
]
return subject_lines
# Example usage
email_body = """
Hi Sarah,
I wanted to follow up on our conversation last week about the Q1 budget proposal.
I've put together the numbers you asked for and I think you'll be pleased with how
we've managed to cut costs while maintaining our growth targets.
Can we schedule 30 minutes this week to walk through it together?
"""
options = generate_subject_lines(email_body)
print("Suggested subject lines:")
for subject in options:
print(f" - {subject}")
This is a realistic, useful tool built with fewer than 40 lines of code. From here, you could add a web interface with FastAPI, wrap it in a Chrome extension, or integrate it into an email client.
Cost Management Tips
A few practical tips to avoid unexpected API bills:
-
Set usage limits in your OpenAI dashboard — you can set a hard monthly cap that stops API calls when you hit the limit.
-
Use gpt-4o-mini for development — it’s significantly cheaper than GPT-4o and good enough for building and testing. Switch to more powerful models only when you need them.
-
Set max_tokens limits — always include a
max_tokensparameter to cap response length. Without it, a verbose model can produce very long responses that cost more than expected. -
Cache responses when appropriate — if you’re sending the same prompt repeatedly (like fetching categories for the same document), cache the result rather than calling the API each time.
For the next step after this tutorial, see our Best Python Libraries for AI Projects guide to understand which libraries you’ll need as your projects get more complex.
Where to Go From Here
Once you have the basics working, the natural next steps are:
Add a web interface: Use FastAPI to expose your chatbot as an API, then add a simple HTML/JavaScript frontend.
Add persistent memory: Store conversation history in a database (SQLite is fine to start) so conversations persist between sessions.
Add retrieval: Use LlamaIndex or a vector database to let your chatbot answer questions about your own documents.
Add tool use: OpenAI’s function calling feature lets your AI trigger actions — searching the web, querying a database, sending emails.
You’ve also just done the core of what most AI applications do at their heart: take user input, send it to a model with some context, and process the response. The complexity of real AI products is mostly in the details of how that context is constructed and how responses are processed.
Conclusion
Building your first app with the OpenAI API is approachable even for beginners — you need basic Python, a free OpenAI account, and one library (openai). The core pattern is simple: construct a messages list, call client.chat.completions.create(), and read response.choices[0].message.content.
From this foundation, you can build anything from a simple script to a full AI application. The chatbot in this tutorial is working production-quality code, not a toy example.
Explore Our Courses to go deeper on building real AI applications, including web interfaces, databases, and deployment.