GenAI Commercial APIs

Use powerful AI models without training your own. Learn the OpenAI and Google AI APIs, how to manage API keys securely, how billing and rate limits work, and how to get embeddings via API.

12.1 What are Commercial AI APIs?

The provider manages all the heavy infrastructure — GPUs, scaling, updates. You just send a request and get a response. Key characteristics:

• REST-based — JSON requests and JSON responses over HTTP.
• Pay-as-you-go — subscription or usage-based pricing; no fixed cost to start.
• Authenticated — every request needs a valid API key.
• Enterprise-grade — built for security and scalability.

12.2 OpenAI API & Google AI API

OpenAI API

Gives access to OpenAI's models via HTTP requests for text generation, summarization, translation and embeddings. Core components:

OpenAI offers chat models (conversations, Q&A), embedding models (search, RAG), lightweight models (low-cost tasks) and advanced models (complex reasoning).

Google AI API (Gemini)

Gemini is Google's AI model family — text, reasoning, code, and some image support — accessed via Google AI Studio or Vertex AI, using REST or SDKs. It is part of the broader Google Cloud ecosystem and integrates with BigQuery and Cloud Storage.

OpenAI vs Google AI

import os
from openai import OpenAI

# Key is read from an environment variable - NEVER hard-coded
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Explain RAG in one line."}]
)
print(response.choices[0].message.content)

12.3 API Key Management

API key lifecycle

Best practices for storing keys

• Store keys in environment variables, not in source code.
• Use a secrets manager for stronger protection.
• Never expose keys in frontend code — the browser can be inspected by anyone.
• Keep API calls on the backend server.
• Rotate keys periodically and limit access by role/environment.

12.4 Costs, Billing & Rate Limits

Token-based pricing

OpenAI charges based on the number of tokens processed — and this counts both directions:

• Input tokens — the size of your prompt.
• Output tokens — the size of the model's response.

Different models have different per-token prices: lightweight models are cheaper but less capable; advanced models cost more but reason better. Pricing is usage-based with no fixed monthly fee by default.

Rate Limits

Limits may apply per API key, per user, or per IP. Exceeding them temporarily blocks requests.

Handling rate limits gracefully

• Exponential backoff — on a 429, wait, retry; if it fails again wait longer, retry; keep doubling the wait. This avoids hammering the server.
• Queue requests instead of sending bursts.
• Cache results to avoid duplicate calls.
• Monitor usage; upgrade the plan for higher throughput.

import time

def call_with_backoff(make_request, max_retries=5):
    delay = 1
    for attempt in range(max_retries):
        response = make_request()
        if response.status_code != 429:        # success or other error
            return response
        print(f"Rate limited. Waiting {delay}s...")
        time.sleep(delay)
        delay *= 2                             # double the wait each time
    raise Exception("Still rate-limited after retries")

12.5 Word Embeddings via API

Both OpenAI and Google offer dedicated embedding models via API. They convert text into fixed-length numerical vectors that capture semantic meaning — the foundation of search, recommendations and RAG (Lecture 16).

• Similar texts → vectors that are close in vector space.
• Embeddings are generated once and reused — far cheaper than re-generating text.
• They are stored in vector databases for fast similarity search.

import os
from openai import OpenAI

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

response = client.embeddings.create(
    model="text-embedding-3-small",
    input="How many vacation days do I get?"
)
vector = response.data[0].embedding
print("Embedding length:", len(vector))   # a fixed-length numeric vector

API security and rate limits are common MCQ material.

import os
from openai import OpenAI

# Read the key from the environment - never hard-code it
api_key = os.environ.get("OPENAI_API_KEY")
if api_key is None:
    raise ValueError("OPENAI_API_KEY not set")

client = OpenAI(api_key=api_key)
print("Client created securely.")

import os
from openai import OpenAI

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

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "user",
         "content": "Summarise photosynthesis in one sentence"}
    ]
)
print(response.choices[0].message.content)