OpenAI API Fundamentals

Understanding openai api fundamentals is the foundation of this guide. Below we break it down step by step so you can act with confidence.

The OpenAI API is the backbone of most AI automations. This lesson covers everything you need to build with it: authentication, model choices, pricing math, and production code patterns.

Every code sample is copy-paste ready with Python.

Openai Api Fundamentals: Setup and Authentication

pip install openai
export OPENAI_API_KEY="sk-your-key-here"

import openai, os

client = openai.OpenAI(api_key=os.environ["OPENAI_API_KEY"])

# Verify the key works
models = client.models.list()
print(f"Access to {len(list(models))} models")

Models and Pricing

Choose the right model for each task:

• gpt-4o — best quality, $2.50/1M input, $10/1M output — use for complex reasoning, coding, analysis
• gpt-4o-mini — fast and cheap, $0.15/1M input, $0.60/1M output — use for classification, extraction, simple generation
• o1 — reasoning model, $15/1M input, $60/1M output — use for math, logic, multi-step problems
• gpt-4o-mini is the automation workhorse — 95% of automation tasks work perfectly with it

import tiktoken

def estimate_cost(text: str, model: str = "gpt-4o-mini") -> dict:
    pricing = {
        "gpt-4o-mini": {"input": 0.15, "output": 0.60},
        "gpt-4o":      {"input": 2.50, "output": 10.00},
    }
    enc = tiktoken.encoding_for_model(model)
    input_tokens = len(enc.encode(text))
    est_output = input_tokens // 2  # rough estimate
    cost = (input_tokens * pricing[model]["input"] + est_output * pricing[model]["output"]) / 1_000_000
    return {"input_tokens": input_tokens, "est_output_tokens": est_output, "est_cost_usd": round(cost, 6)}

print(estimate_cost("Analyze this quarterly report..." * 100))
# {'input_tokens': 400, 'est_output_tokens': 200, 'est_cost_usd': 0.00018}

Chat Completions API

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "You are a data analyst. Be concise."},
        {"role": "user", "content": "What are the top 3 KPIs for a SaaS business?"}
    ],
    temperature=0.3,       # lower = more deterministic
    max_tokens=500,        # cap output length
    top_p=1.0,             # nucleus sampling
    frequency_penalty=0.0, # reduce repetition
    presence_penalty=0.0,  # encourage new topics
)

print(response.choices[0].message.content)
print(f"Tokens used: {response.usage.total_tokens}")

Streaming Responses

stream = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Explain microservices in 5 bullet points."}],
    stream=True
)

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

final_text = "".join(full_response)

Function Calling (Tool Use)

tools = [{
    "type": "function",
    "function": {
        "name": "save_contact",
        "description": "Save extracted contact information",
        "parameters": {
            "type": "object",
            "properties": {
                "name":    {"type": "string", "description": "Full name"},
                "email":   {"type": "string", "description": "Email address"},
                "company": {"type": "string", "description": "Company name"},
                "role":    {"type": "string", "description": "Job title"}
            },
            "required": ["name", "email"]
        }
    }
}]

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content":
        "Extract contact: John Smith, CTO at Acme Corp, [email protected]"}],
    tools=tools,
    tool_choice="auto"
)

import json
call = response.choices[0].message.tool_calls[0]
contact = json.loads(call.function.arguments)
print(contact)
# {'name': 'John Smith', 'email': '[email protected]', 'company': 'Acme Corp', 'role': 'CTO'}

When evaluating openai api fundamentals, start with the fundamentals: what problem it solves, who it serves, and how it compares to the alternatives buyers consider first.

Start with the fundamentals. Define who you are serving, the single outcome you want, and the budget you are comfortable committing before you compare any options.

A practical rule is to favour clarity over cleverness. The choice that is easiest to understand, spell, remember and act on tends to win over the long run.

Context changes the answer. What is optimal for a fast-moving startup is rarely optimal for an established brand, so weigh your own stage, market and ambitions.

Avoid the common mistakes: rushing the decision, copying competitors blindly, and ignoring the total cost of ownership beyond the very first year of use.

Think in terms of trade-offs rather than a single perfect answer. Every option trades memorability, cost, reach and flexibility in a slightly different mix.

Document your reasoning. Writing down why you chose one path makes it far easier to revisit the decision later and to explain it to partners and investors.

Test with real people. A quick check with a handful of your actual customers will surface problems that no amount of internal debate ever reveals.

Plan for growth. The option that fits today should still make sense when your audience, catalogue or team is several times larger than it is right now.

Finally, revisit the decision periodically. Markets, tools and best practices move quickly, and a choice that was ideal last year may deserve a fresh look today.

When evaluating openai api fundamentals, start with the fundamentals: what problem it solves, who it serves, and how it compares to the alternatives buyers consider first.

Frequently asked questions

What is the rate limit?

Tier 1 accounts get 500 RPM for gpt-4o-mini and 500 RPM for gpt-4o. Limits increase with usage. Implement exponential backoff.

Should I use the Assistants API or Chat Completions?

Chat Completions for automation. The Assistants API adds state management useful for chatbots but unnecessary overhead for pipelines.

How do I keep costs low?

Use gpt-4o-mini for 95% of tasks, cache frequent prompts, batch requests, and set max_tokens to limit output.