The OpenAI API is the engine that runs ChatGPT — but accessible directly, programmatically, without the chat interface. This matters because the interface imposes limitations that the API does not: you cannot automate tasks through the interface, you cannot integrate ChatGPT into your existing tools, you cannot process hundreds of documents automatically, and you cannot build custom applications that other people use.
The API removes all these limitations. And getting started takes significantly less technical knowledge than most people assume.
This guide walks you through everything from scratch: what the API gives you, getting your key and setting up billing, understanding what you will actually pay, making your first API call with copy-paste ready commands, and three practical automations that work immediately.
🔗 This is Post #9 in the ChatGPT Unlocked series. For advanced production patterns, see Building with OpenAI (Post #19). For building custom AI assistants on top of the API, see The Assistants API (Post #10).
Why the API vs. ChatGPT Interface
ChatGPT interface (chat.openai.com): Manual, conversational, one session at a time. You type, it responds, you type again. Rate limits by plan. Cannot be automated.
OpenAI API: Programmatic, automatable, scalable. Send a message from code, get a response in code, do something with that response — all without a browser. Process 500 documents overnight. Build a tool your whole team uses. Connect ChatGPT to your email, your CRM, your spreadsheets.
When the API is worth the setup:
- You need to process the same type of content repeatedly at volume
- You want to integrate AI into existing tools (email, sheets, Slack)
- You are building something other people will use
- You want consistent behavior with fine-grained control
When the interface is enough:
- One-off tasks
- Conversational exploration
- Anything where you want to stay hands-on for each interaction
Step 1: API Account and Key Setup
The API is managed through the OpenAI Platform at platform.openai.com — separate from chat.openai.com but linked to the same account.
Creating Your Platform Account
- Go to platform.openai.com
- Sign in with your OpenAI account (same email as ChatGPT)
- Complete identity verification if prompted
- You land on the Platform dashboard
Getting Your API Key
- Click API Keys in the left sidebar
- Click Create new secret key
- Name it descriptively: “Personal Automation” or “Work Projects”
- Copy the key immediately — it is shown only once
- Store it in a password manager (Bitwarden, 1Password)
Security rule: Your API key is a password. Anyone with it uses OpenAI on your bill. Never paste it into email, never commit it to GitHub, never share it in a document others can access. If you accidentally expose it: delete it immediately in the Platform dashboard and create a new one.
Setting Up Billing and Limits
- Platform dashboard → Billing → Add payment method
- Critical: Set a monthly spending limit before anything else
- Billing → Usage limits → Set monthly limit ($10–25 for beginners)
- This prevents runaway costs if a script loops unexpectedly
API Free Credits
New OpenAI Platform accounts receive a small amount of free credits. Check the Billing section of your dashboard for current credit balance.
Step 2: Understanding API Costs
The API charges per token (approximately ¾ of a word). Input tokens (what you send) and output tokens (what comes back) are priced separately.
Approximate Pricing (Verify at platform.openai.com/pricing)
| Model | Input (per 1M tokens) | Output (per 1M tokens) |
|---|---|---|
| GPT-5.5 | ~$10.00 | ~$30.00 |
| GPT-5.4 | ~$5.00 | ~$15.00 |
| GPT-5.3 Instant | ~$0.50 | ~$2.00 |
| GPT-5.4 mini | ~$0.15 | ~$0.60 |
What Tasks Actually Cost
| Task | Approximate Cost |
|---|---|
| Summarize a 1-page document (GPT-5.3) | ~$0.001 |
| Draft a 500-word article (GPT-5.4) | ~$0.01 |
| Classify 1,000 customer emails (GPT-5.4 mini) | ~$0.10 |
| Analyze a 50-page report (GPT-5.4) | ~$0.08 |
| Complex reasoning task (GPT-5.5) | ~$0.05–0.20 |
For personal automation and small business use: typically $2–15/month.
Cost optimization rule: Use GPT-5.4 mini or GPT-5.3 Instant for classification, extraction, and simple tasks where quality difference is minimal. Reserve GPT-5.4 and GPT-5.5 for tasks requiring genuine quality.
Step 3: Your First API Call
On Mac or Linux (Terminal)
Replace YOUR_API_KEY with your actual key:
curl https://api.openai.com/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_API_KEY" \
-d '{
"model": "gpt-5.4",
"messages": [
{
"role": "user",
"content": "What is the OpenAI API in one sentence?"
}
],
"max_tokens": 100
}'
Run it in Terminal. You will see a JSON response containing the model’s answer. That is the API.
On Windows (PowerShell)
$headers = @{
"Content-Type" = "application/json"
"Authorization" = "Bearer YOUR_API_KEY"
}
$body = @{
model = "gpt-5.4"
messages = @(
@{role = "user"; content = "What is the OpenAI API in one sentence?"}
)
max_tokens = 100
} | ConvertTo-Json
Invoke-RestMethod -Uri "https://api.openai.com/v1/chat/completions" `
-Method POST -Headers $headers -Body $body
Step 4: Python Setup (Copy-Paste Ready)
Installing Python and the OpenAI Library
If Python is not installed: python.org → Downloads → Install.
Then in Terminal/Command Prompt:
pip install openai
Storing Your API Key Safely
Mac/Linux — add to ~/.zshrc or ~/.bashrc:
export OPENAI_API_KEY="your-key-here"
Windows PowerShell:
$env:OPENAI_API_KEY = "your-key-here"
Your First Python Script
Create openai_test.py:
from openai import OpenAI
client = OpenAI() # Reads OPENAI_API_KEY from environment
response = client.chat.completions.create(
model="gpt-5.4",
messages=[
{
"role": "user",
"content": "Explain the OpenAI API in plain English in 3 sentences."
}
]
)
print(response.choices[0].message.content)
Run: python openai_test.py
Three Practical Automations
Automation 1: Batch Document Summarizer
Summarize every text file in a folder automatically:
from openai import OpenAI
import os
from pathlib import Path
client = OpenAI()
input_folder = Path("documents/")
output_folder = Path("summaries/")
output_folder.mkdir(exist_ok=True)
for file_path in input_folder.glob("*.txt"):
text = file_path.read_text(encoding="utf-8")
print(f"Summarizing: {file_path.name}")
response = client.chat.completions.create(
model="gpt-5.4-mini", # Cost-efficient for simple summarization
messages=[
{
"role": "system",
"content": "Summarize documents in exactly one paragraph. "
"Include the main purpose, key points, and "
"most important recommendation or conclusion."
},
{
"role": "user",
"content": f"Summarize this document:\n\n{text[:8000]}"
}
],
max_tokens=300
)
summary = response.choices[0].message.content
output_path = output_folder / f"{file_path.stem}_summary.txt"
output_path.write_text(summary)
print(f" → Saved: {output_path.name}")
print(f"\nDone! Summaries saved to {output_folder}/")
Cost for 50 documents: approximately $0.05
Automation 2: Email Classifier
Classify emails by urgency and category, returning structured JSON:
from openai import OpenAI
import json
client = OpenAI()
def classify_email(subject: str, body: str) -> dict:
response = client.chat.completions.create(
model="gpt-5.4-mini",
messages=[
{
"role": "system",
"content": """Classify emails and return ONLY valid JSON:
{
"urgency": "high|medium|low",
"category": "client|vendor|internal|spam|other",
"action_required": true|false,
"summary": "one sentence",
"suggested_response_time": "same day|within 48h|this week|no response needed"
}
Return only the JSON object, nothing else."""
},
{
"role": "user",
"content": f"Subject: {subject}\n\nBody: {body}"
}
],
max_tokens=150
)
return json.loads(response.choices[0].message.content)
# Example
result = classify_email(
"URGENT: Server down — customers cannot log in",
"Our production server has been unreachable for 15 minutes. "
"Multiple customers are reporting login failures. Need immediate help."
)
print(f"Urgency: {result['urgency']}")
print(f"Category: {result['category']}")
print(f"Summary: {result['summary']}")
print(f"Respond: {result['suggested_response_time']}")
Automation 3: Google Sheets AI Formula (Apps Script)
In Google Sheets → Extensions → Apps Script:
const OPENAI_API_KEY = 'YOUR_API_KEY_HERE';
/**
* Custom function: =GPT(A2, "Classify this feedback as Positive/Neutral/Negative")
*/
function GPT(inputText, instruction) {
if (!inputText) return '';
const payload = {
model: 'gpt-5.4-mini',
max_tokens: 100,
messages: [
{
role: 'system',
content: 'Follow the instruction precisely. Return only the requested output.'
},
{
role: 'user',
content: `${instruction}\n\nText: ${inputText}`
}
]
};
const options = {
method: 'post',
contentType: 'application/json',
headers: {'Authorization': `Bearer ${OPENAI_API_KEY}`},
payload: JSON.stringify(payload)
};
const response = UrlFetchApp.fetch(
'https://api.openai.com/v1/chat/completions',
options
);
const data = JSON.parse(response.getContentText());
return data.choices[0].message.content.trim();
}
Usage in Google Sheets:
=GPT(A2, "Classify as Positive, Neutral, or Negative")=GPT(A2, "Extract the company name from this text")=GPT(A2, "Summarize in one sentence")=GPT(A2, "Translate to Spanish")
Rate Limits and Error Handling
from openai import OpenAI, RateLimitError, APIError
import time
client = OpenAI()
def call_with_retry(messages, model="gpt-5.4", max_retries=3):
for attempt in range(max_retries):
try:
response = client.chat.completions.create(
model=model,
messages=messages,
max_tokens=1000
)
return response.choices[0].message.content
except RateLimitError:
wait = 2 ** attempt
print(f"Rate limit hit. Waiting {wait}s...")
time.sleep(wait)
except APIError as e:
if e.status_code in (500, 503):
time.sleep(2 ** attempt)
else:
raise
raise RuntimeError(f"Failed after {max_retries} attempts")
Connecting to Zapier and Make.com
For zero-code integration:
Zapier: Search for “OpenAI” in Zapier’s app directory. Connect your API key. Available as a trigger or action in any Zap. Example: New Gmail → Extract action items with GPT-5.4 → Add to Notion.
Make.com: Use the HTTP module to call the API directly:
- URL:
https://api.openai.com/v1/chat/completions - Method: POST
- Headers:
Authorization: Bearer YOUR_KEY - Body: JSON request as above
Conclusion
The API removes the ceiling that the interface imposes. Once your API key is set up and billing is configured, the practical barrier to automating a repetitive AI task is 20–30 minutes of working from the templates in this guide.
Your next step: Go to platform.openai.com, generate your API key, set a $10 monthly spending limit, and run the curl command from Step 3. You have made your first API call. Everything else is a variation on that pattern.
📚 Continue the Series:
- ← Previous ChatGPT Data Analysis
- Next → OpenAI Assistants API: Build a Custom AI Assistant
- Advanced patterns Building with OpenAI
Last updated: May 2026. Verify current model names and pricing at platform.openai.com.
⚠️ Set a billing spending limit before running any automation. Secure your API key. Never commit it to version control.