Recommended Free Tools
To use what many people call the “ChatGPT API,” create an OpenAI API key, keep it on a server, choose an API surface and model for your task, then send a request with an official client library or HTTP. For a first text or tool-enabled model request, start with the Responses API. Before building beyond a prototype, plan for model and usage costs, errors, rate limits, request IDs, and data retention.
What people mean by the “ChatGPT API”
“ChatGPT API” is common shorthand, but the developer products are referred to as the OpenAI API. The API offers distinct surfaces for different interaction patterns; they are not interchangeable names for the same endpoint. This tutorial starts with a server-side request to the Responses API and explains when another surface may be a better fit.
As an Amazon Associate I earn from qualifying purchases.
Get an API key and protect it
- Create a key. Sign in to the OpenAI developer dashboard and create an API key for your project. Treat the key like a password: anyone who obtains it may be able to make API requests under your account.
- Store it outside your code. Set it as a server-side environment variable, such as
OPENAI_API_KEY, or use a secrets-management service. Do not commit it to a repository or put it in browser JavaScript, a mobile app, or any other client code that users can inspect. - Keep requests behind your server. Have your web or mobile client call your own backend; let that backend authenticate the user, apply your limits, and call the OpenAI API. This prevents the API key from being exposed to every user of your application.
Make a first request with the Responses API
The official client libraries handle the HTTP details and read the API key from the environment. For example, in a Node.js server project, install the OpenAI package with npm install openai, set OPENAI_API_KEY in the server environment, and set OPENAI_MODEL to a model ID currently listed in the model catalog. Model availability changes, so do not assume a model ID copied from an old example is still the right choice.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: process.env.OPENAI_MODEL,
input: "Give me three concise ideas for a weekend project."
});
console.log(response.output_text);Run this from a server environment where both variables are set. The request sends a text input to the selected model; response.output_text provides a convenient way to read generated text. In a real application, return only the result your user needs, not credentials or internal request details.
#1 Best Overall
You can also call the API directly over HTTP if you need lower-level control or do not want to use an SDK. In either case, send the API key as a server-side authorization credential, not as part of a URL or a response sent to the browser. The quickstart also demonstrates ways to extend a basic request with streaming, images, files, built-in tools, and an agent-style example; each adds requirements beyond this minimal text call.
Choose the API surface for the interaction
| Need | Surface to consider | Why |
|---|---|---|
| General model requests, including text, image, audio, and tool workflows, or interactions that need state | Responses | It is the recommended starting point for direct model requests and supports a broad set of model interactions. |
| Low-latency voice or audio sessions | Realtime | It is intended for realtime sessions rather than ordinary request-and-response workflows. |
| Organization-level management tasks | Administration | It serves organization workflows rather than a typical end-user model interaction. |
Choose based on the product’s interaction pattern and required modalities, not just the word “chat.” A single response, streamed output, a stateful exchange, and a live voice session can have different implementation and operational needs.
Select a model and estimate cost
There is no universally best model for every application. Compare the current model catalog against the work you need to do: required input and output modalities, tool support, task quality, latency, and your expected usage. Test representative requests for your own product before settling on a model.
Check the live pricing page before estimating or launching. API surfaces are not separately priced in themselves; usage is charged according to the selected model’s applicable input and output rates, and tools or other services may add charges. Rates, model availability, and promotions can change, so a token price copied into an undated tutorial is not a reliable estimate of your bill.
For a useful budget, estimate how many requests you expect, how much input each request carries, how much output you expect, and whether the workflow calls tools or other services. Revisit those assumptions when prompts, traffic, model choice, or product behavior changes.
Prepare a prototype for production
Handle errors and rate limits
A successful test call does not establish that an application is ready for real traffic. Add error handling for failed requests and rate limits, and decide how your application should respond when a request cannot be completed. Retry only when appropriate; use bounded retries with backoff rather than an immediate, unending retry loop. Keep user-facing messages separate from internal diagnostics.
Log request IDs safely
Capture request IDs returned with API responses or errors where available. They help correlate an application event with a specific API request when investigating a failure. Log them alongside useful operational context, but avoid logging API keys or unnecessary sensitive prompt and response content.
Keep the key and application controls on the server
Use server-side configuration or a key-management service, restrict access to the credential, and avoid exposing it in logs or client responses. Your backend should also apply its own authorization and usage controls; an API key alone does not determine which of your application’s users should be allowed to make a request.
Best Value
Understand data use, retention, and state
OpenAI says API data is not used to train or improve its models unless a customer opts in. That does not mean requests are never retained: abuse-monitoring logs may contain request content and are retained for up to 30 days by default, subject to exceptions.
Application state depends on the endpoint, feature, and settings used. A stateless-looking example should not be taken as a guarantee about every endpoint or feature. Before sending sensitive information, check the current data-controls guidance for the specific endpoint and features in your application, including applicable retention options and any regional requirements relevant to your deployment.
For a real product, decide what data it needs to send, what your own application stores, and how long it keeps it. Minimize unnecessary content in requests and logs, and make sure your user-facing privacy commitments reflect the behavior of both your application and the API features you use.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
