Artificial Intelligence

How to Use ChatGPT API in Python for Beginners: A Complete Practical Guide

  • July 2, 2026
  • Com 0

How to Use ChatGPT API in Python for Beginners

A student recently came to me after finishing a machine learning course, confident and ready to build something real. He wanted to create a simple chatbot for his final year project. He knew Python well, understood functions and loops without any trouble, but the moment he opened the OpenAI documentation, he froze. API keys, endpoints, request bodies, none of it looked like the Python he had learned in class. He closed the tab and messaged me asking where to even begin.

This happens constantly. Students learn Python as a language, but nobody teaches them how to actually connect Python to a real, live service like ChatGPT. The gap between knowing Python and knowing how to use an API feels much bigger than it actually is, mostly because nobody breaks it down properly from the start.

This guide walks through exactly that, from installing what you need to writing your first working request, understanding what is actually happening behind each line of code, and building something practical enough to put on your resume or GitHub profile.

What Is the ChatGPT API and How Is It Different From the ChatGPT Website

Most people first experience ChatGPT through the website, where you type a message and get a reply in a chat window. The API is a different way of accessing the same underlying model, except instead of typing into a browser, your own code sends the request and receives the response directly.

This distinction matters because it changes what becomes possible. Through the website, ChatGPT is a tool you use manually. Through the API, ChatGPT becomes a component you can build into your own applications. A student project, a customer support tool, a resume screening assistant, a study helper app, all of these become possible once you can call the model directly from your own code and control exactly how it behaves.

The API also works differently in terms of cost and access. The ChatGPT website subscription and the API are billed separately. The API is generally pay as you go, meaning you are charged based on how much text you send and receive, measured in units called tokens, which roughly correspond to pieces of words.

Setting Up Your Environment

Before writing any code, a few things need to be in place.

First, you need Python installed on your machine, ideally version 3.8 or newer. Running python –version in your terminal confirms which version you currently have.

Second, you need an OpenAI account and an API key. This is created by signing up on the OpenAI platform website and generating a key from the API keys section of your account dashboard. This key is essentially a password that identifies your account and tracks your usage, so it should never be shared publicly or committed to a public GitHub repository, since anyone with your key can use your account and run up charges on your behalf.

Third, you need to install the official OpenAI Python library. This is done through pip, Python’s package manager, by running the following command in your terminal.

pip install openai

Once this completes, the library is available to import directly into your Python scripts.

If you are new to running Python scripts through the terminal, it helps to be comfortable with basic command line navigation before going further. Our complete guide to Linux commands for beginners covers everything needed to move around confidently before diving into API projects like this one.

 

Keeping Your API Key Safe

Before writing the first line of actual code, it is worth addressing something that catches almost every beginner off guard at some point, which is API key security.

A common mistake is typing the API key directly into the Python script as plain text, then later uploading that script to GitHub without realizing the key is sitting right there in the code, visible to anyone who looks at the repository. Automated bots constantly scan public GitHub repositories specifically looking for exposed API keys, and a leaked key can result in unexpected charges within hours.

The safer approach is storing the key in a separate file that never gets uploaded to GitHub. Create a file named .env in your project folder and add this single line, replacing the placeholder with your actual key.

OPENAI_API_KEY=your-actual-key-here

Then install a small library that reads this file automatically.

pip install python-dotenv

At the top of your Python script, load the key like this.

from dotenv import load_dotenv
import os

load_dotenv()
api_key = os.getenv(“OPENAI_API_KEY”)

This keeps the actual key out of your code entirely. If you push this project to GitHub, make sure to add a file named .gitignore in the same folder containing the line .env, which tells Git to never track or upload that file.

 

Writing Your First API Request

With the setup complete, here is a complete, working example that sends a message to ChatGPT and prints the response.

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()
client = OpenAI(api_key=os.getenv(“OPENAI_API_KEY”))

response = client.chat.completions.create(
model=”gpt-4o-mini”,
messages=[
{“role”: “user”, “content”: “Explain what an API is in one simple sentence.”}
]
)

print(response.choices[0].message.content)

Running this script sends your message to the model and prints back a short explanation. If this runs successfully and prints a real response, everything is correctly configured.

Let us break down what each part is actually doing, since understanding this matters more than simply copying it.

The OpenAI object, created using your API key, is your connection to the service. Every request you send goes through this client. The model parameter specifies which version of the model you want to use. Different models vary in cost, speed, and capability, and choosing the right one depends on what you are building. The messages parameter is a list containing the conversation. Each message has a role, which is either user, assistant, or system, and content, which is the actual text of that message.

The response that comes back is a structured object, not just plain text. The actual reply is found inside response.choices[0].message.content, which is why the print statement navigates through that specific path to reach the text.

 

Understanding Roles and Building a Conversation

A single message exchange is useful, but most real applications need to maintain a conversation, where the model remembers what was said earlier.

This is done by including the full conversation history in the messages list on every request, since the API itself does not remember previous requests on its own. Each request is independent, and it is your code’s responsibility to keep track of the conversation and send the relevant history back each time.

Here is an example that maintains a short back and forth conversation.

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()
client = OpenAI(api_key=os.getenv(“OPENAI_API_KEY”))

conversation = [
{“role”: “system”, “content”: “You are a helpful coding tutor who explains things simply.”},
{“role”: “user”, “content”: “What is a variable in Python?”}
]

response = client.chat.completions.create(
model=”gpt-4o-mini”,
messages=conversation
)

reply = response.choices[0].message.content
print(reply)

conversation.append({“role”: “assistant”, “content”: reply})
conversation.append({“role”: “user”, “content”: “Can you give me an example?”})

response2 = client.chat.completions.create(
model=”gpt-4o-mini”,
messages=conversation
)

print(response2.choices[0].message.content)

Notice the system role used at the very start. This message sets the overall behavior and personality of the assistant for the entire conversation, and it is not visible to the end user in most applications, but it strongly shapes how the model responds. Setting a clear system message is one of the most underused techniques by beginners, and it is often the difference between generic, unfocused responses and ones that consistently match what you actually need.

 

Building a Simple Command Line Chatbot

With the core concept understood, it becomes straightforward to build a basic interactive chatbot that runs in the terminal, which is a common beginner project and a genuinely useful thing to show in a portfolio.

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()
client = OpenAI(api_key=os.getenv(“OPENAI_API_KEY”))

conversation = [
{“role”: “system”, “content”: “You are a friendly assistant who answers clearly and concisely.”}
]

print(“Chatbot ready. Type exit to end the conversation.”)

while True:
user_input = input(“You: “)


if user_input.lower() == “exit”:
break

conversation.append({“role”: “user”, “content”: user_input})

response = client.chat.completions.create(
model=”gpt-4o-mini”,
messages=conversation
)

reply = response.choices[0].message.content
print(“Bot:”, reply)

conversation.append({“role”: “assistant”, “content”: reply})

This small script is genuinely a complete, working chatbot. It maintains conversation history, sends it to the API on every message, and prints the response back in a loop until the user types exit. Projects like this, small but fully functional, are exactly the kind of thing that stands out on a GitHub profile because they demonstrate real, working use of an API rather than just following a tutorial passively.

 

Controlling the Response With Parameters

Beyond the basic setup, a few parameters give meaningful control over how the model responds, and understanding them separates a beginner script from a properly configured application.

The temperature parameter controls how random or predictable the output is, on a scale generally from 0 to 2. A lower value, such as 0.2, produces more focused, consistent, and predictable answers, which is useful for tasks like data extraction or factual question answering. A higher value, such as 1.2, produces more varied and creative responses, which suits tasks like story writing or brainstorming.

response = client.chat.completions.create(
model=”gpt-4o-mini”,
messages=conversation,
temperature=0.3
)

The max_tokens parameter limits how long the response can be, measured in tokens rather than words or characters. Setting this prevents unexpectedly long responses and helps control cost, since longer responses use more tokens and cost more.

response = client.chat.completions.create(
model=”gpt-4o-mini”,
messages=conversation,
max_tokens=150
)

Adjusting these two parameters alone covers most practical needs for a beginner project, whether the goal is precise, factual answers or more open ended, creative output.

 

Handling Errors Properly

Real applications need to handle situations where something goes wrong, such as network issues, invalid API keys, or running out of API credits. Beginners often skip this entirely, which results in scripts that crash with unclear error messages the moment something unexpected happens.

from openai import OpenAI, APIError
from dotenv import load_dotenv
import os

load_dotenv()
client = OpenAI(api_key=os.getenv(“OPENAI_API_KEY”))

try:
response = client.chat.completions.create(
model=”gpt-4o-mini”,
messages=[{“role”: “user”, “content”: “Hello”}]
)
print(response.choices[0].message.content)
except APIError as e:
print(“Something went wrong while contacting the API:”, e)

Wrapping API calls in a try and except block ensures that if something fails, your program handles it gracefully instead of crashing outright, which matters significantly once this code is part of a real application that other people might actually use.

 

A Practical Project Idea: A Resume Feedback Tool

To bring everything together, here is a slightly more complete example that many students find genuinely useful, a small script that takes a piece of resume text and returns feedback on it, something directly relevant to job seekers.

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()
client = OpenAI(api_key=os.getenv(“OPENAI_API_KEY”))

resume_text = “””
Aman Sharma
Final year Computer Science student.
Built a portfolio website and a basic expense tracker app.
Skilled in Python, JavaScript, and SQL.
“””

response = client.chat.completions.create(
model=”gpt-4o-mini”,
messages=[
{“role”: “system”, “content”: “You are a career advisor who gives honest, specific feedback on resumes.”},
{“role”: “user”, “content”: f”Give me three specific pieces of feedback to improve this resume summary:\n{resume_text}”}
],
temperature=0.4
)

print(response.choices[0].message.content)

This small example shows how a real world problem, getting resume feedback, can be solved with a genuinely simple script. Extending this into a small web application, with a text box for input and the response displayed on screen, is a natural next step for anyone wanting to turn this into a full project for their portfolio.

 

Common Mistakes Beginners Make

Hardcoding the API key directly into the script and later uploading it to GitHub is by far the most common and most costly mistake, since it exposes the key publicly and can lead to unexpected charges if it gets picked up by automated scanners.

Sending the entire conversation history on every single request without any limit is another issue that beginners run into once conversations get long, since this increases both cost and the chance of hitting token limits. Trimming older parts of the conversation once it grows past a reasonable length keeps things efficient.

Not handling errors at all is a mistake that only becomes obvious once a script is actually used regularly, since network issues and rate limits do happen, and a script that crashes completely on the first error is not something you would want to demonstrate in an interview.

Choosing an unnecessarily expensive or powerful model for a simple task is another common oversight. Not every project needs the most advanced available model, and choosing a lighter, faster model for simple tasks keeps both cost and response time significantly lower.

Ignoring the temperature and max_tokens parameters entirely and relying only on default settings often produces responses that are either too long, too random, or simply not suited to the specific task at hand.

Frequently Asked Questions

Is the ChatGPT API free to use?

The API is not free the way the ChatGPT website has a free tier. It is billed based on usage, measured in tokens, though new accounts typically receive some initial free credit to experiment with. For learning and small student projects, actual costs tend to be very small, often just a few cents for dozens of test requests.

 

Do I need a powerful computer to use the API?

No. Since the actual processing happens on OpenAI’s servers, your own computer only needs to send a request and receive a response, which requires almost no computing power. Any laptop capable of running Python comfortably can use the API without issue.

 

Which Python library version should beginners use?

The official openai Python library, installed through pip install openai, is the recommended approach, since it is maintained directly by OpenAI and stays updated with the latest features and models.

 

Can this be used to build a website, not just a script?

Yes. The same core logic shown in this guide can be connected to a web framework like Flask or FastAPI, allowing the API calls to power a real website where users interact through a browser instead of a terminal. The underlying API calls remain exactly the same.

 

Is it safe to put a chatbot built like this on a resume or GitHub profile?

Yes, and it is genuinely a strong addition, provided the API key is properly secured using the method shown earlier in this guide and never exposed in the public repository. A working project like this demonstrates real, practical skill with a widely used technology far more effectively than a certificate alone.

 

Why This Skill Matters for Students and Job Seekers

Understanding how to use APIs, and specifically AI APIs like this one, has quickly become one of the more practical, in demand skills for anyone entering the tech industry today. Companies across almost every sector are actively building features powered by tools like the ChatGPT API, and developers who understand how to work with these tools directly, rather than only through a browser interface, have a clear practical advantage.

For a student building a portfolio, a working project using this API demonstrates something a certificate alone cannot, which is the ability to take a real, external service and build something functional with it. For a job seeker, being able to speak confidently about how these systems work in an interview, beyond just having used ChatGPT casually, signals a level of technical understanding that stands out clearly from candidates who have only used it as an end user.

Once you have a working project like this, the next step is making sure it is visible to recruiters in the right way. Uploading it to a properly organized GitHub repository with clear commits and documentation matters just as much as the project itself. Our complete Git and GitHub guide for beginners walks through exactly how to do this the right way.

This is exactly the kind of practical, hands on skill we focus on at TuxAcademy, moving students from simply understanding a concept in theory to actually building something real with it. If you are looking to go deeper into Python, APIs, and applied AI development with structured guidance and real project work, you can explore our programming courses at https://www.tuxacademy.org/.

 

Author Bio

Author: Geetanjali Mehra
AI & Data Science Mentor at TuxAcademy

Experience:

  • Industry mentoring in AI, Data Science, Python, and Machine Learning
  • Hands-on training with enterprise datasets
  • AI project guidance for students and professionals
  • Internship and placement mentoring

Call

Start your Cybersecurity career today with expert-led training and real-world projects.

Website URL: https://www.tuxacademy.org/
Address: SA209, 2nd Floor, Town Central, Ek Murti, Greater Noida West 201009
Email: info@tuxacademy.org
Phone: +91-7982029314

 

Watch Video

Location:

Cyber Security Course Cyber Security Training Course in Delhi NCR Cyber Security Training Course in Delhi Cyber Security Course Near Me Cyber Security Training Course in Greater Noida Cyber Security Training Course in Noida Cyber Security Course in Noida 

Nearby Landmarks & Localities for TuxAcademy (Greater Noida West) Offline Courses:

TuxAcademy is a premier training and research institute strategically located in the heart of Greater Noida West, ensuring seamless accessibility for students from across the NCR region. Positioned near Knowledge Park – one of the most prominent education hubs in North India – the institute benefits from its proximity to key student zones such as Alpha 1 Greater Noida, Alpha 2 Greater Noida, Beta 1 Greater Noida, Gamma 1 Greater Noida, and Delta 1 Greater Noida, making it highly convenient for daily commuting students. The institute enjoys excellent connectivity through major transit points including Pari Chowk, Knowledge Park Metro Station, and the Noida-Greater Noida Expressway, along with close proximity to popular commercial and student hubs such as Jagat Farm Market, Ansal Plaza Greater Noida, and Omaxe Connaught Place Greater Noida.

TuxAcademy is also easily accessible from major residential and student-centric localities including Gaur City, Bisrakh, Techzone 4 Greater Noida West, Crossings Republik, Ek Murti Chowk, Sector 1 Greater Noida West, Sector 16B Greater Noida West, Greater Noida Sector 2, Ecotech 12 Greater Noida, Amrapali Dream Valley, Patwari Village, Milak Lachhi, Cherry County Greater Noida West, Roza Yakubpur, Eco Village 3 Greater Noida West, Iteda Greater Noida, Eco Village 1 Greater Noida West, Greater Noida Sector 8, Roza Jalalpur, Mahagun Mywoods Phase 2, Eco Village 2 Greater Noida West, Amrapali Leisure Valley, Greater Noida Sector 1, Greater Noida Sector 16B, Vedpura, and Charmurti Chowk, reinforcing its reach across densely populated student regions.

Surrounded by leading educational institutions such as Sharda University, Galgotias University, IIMT Group of Colleges, Bennett University, and Noida International University, TuxAcademy is ideally positioned within a thriving academic ecosystem. This strategic location, combined with strong connectivity and proximity to key landmarks, makes TuxAcademy a preferred destination for students seeking industry-focused, job-oriented training in Artificial Intelligence, Data Science, Cyber Security, Full Stack Development, and Python programming, while also ensuring strong visibility in Google search results for learners across Noida Extension, Greater Noida West, and nearby areas.

 

Linux Commands Every IT Student Should Know Before Their First Job
What Is Social Engineering and How Hackers Manipulate People to Bypass Security