OpenAI Responses API: The Ultimate Developer Guide

What Is OpenAI’s Responses API?

The Responses API is OpenAI’s newest and most advanced API. It combines the strengths of the Chat Completions and Assistants APIs into a single streamlined interface. Released in March 2025, it maintains familiar capabilities while providing a more integrated approach to building AI applications. 

The key innovation is how it simplifies development by automatically handling orchestration logic and natively integrating OpenAI’s built-in tools for web search and file search without requiring custom implementation.

In this tutorial, we’ll walk through how to use the Responses API in your projects. You’ll see how it handles text generation, works with images, and delivers streaming responses. We’ll examine the built-in tools that make development faster and more straightforward than before, showing you how these tools work together within the API’s framework. 

By the end of this guide, you’ll understand when to use the Responses API instead of other OpenAI options and how this knowledge can help you build more efficient applications with less code and effort. If you’re new to the OpenAI API, check out our introductory course, Working with the OpenAI API, to start your journey developing AI-powered applications.

Getting Started With the Responses API

The Responses API provides a more streamlined and user-friendly interface for interacting with OpenAI’s models, combining what previously required verbose and complex syntax into an elegant solution. 

Before diving into specific use cases, let’s set up our environment and understand the basic syntax.

from openai import OpenAI
import os
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

# Initialize the client
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

This initialization step creates a client object that will handle all your API requests. The dotenv package helps manage your API key securely through environment variables rather than hardcoding it in your script — a best practice that makes your code more portable and secure across different environments.

Generating content with the Responses API

The most straightforward use of the Responses API is generating text content. Let’s explore a real-world scenario: suppose you’re building an e-commerce platform and need to automatically generate compelling product descriptions based on basic product details.

Traditionally, this would require careful prompt engineering and multiple iterations. With the Responses API, you can create a simple function that handles this elegantly:

def generate_product_description(product_name, features, target_audience):
   response = client.responses.create(
       model="gpt-4o",
       instructions="You are a professional copywriter specialized in creating concise, compelling product descriptions. Focus on benefits rather than just features.",
       input=f"""
       Create a product description for {product_name}.
       Key features:
       - {features[0]}
       - {features[1]}
       - {features[2]}
       Target audience: {target_audience}
       Keep it under 150 words.
       """,
       temperature=0.7,
       max_output_tokens=200
   )
  
   return response.output_text

# Example usage
headphones_desc = generate_product_description(
   "NoiseGuard Pro Headphones",
   ["Active noise cancellation", "40-hour battery life", "Memory foam ear cushions"],
   "Business travelers and remote workers"
)

print(headphones_desc)

Output:

Experience unparalleled focus and comfort with NoiseGuard Pro Headphones—your perfect travel and work companion. 
Designed for business travelers and remote workers, these headphones feature cutting-edge active noise cancellation to block out distractions, allowing you to concentrate on what truly matters. 
With an impressive 40-hour battery life, you can enjoy uninterrupted productivity or relaxation on even the longest journeys. 
The luxurious memory foam ear cushions ensure a snug, comfortable fit for all-day wear, reducing fatigue and enhancing your listening experience. 
Elevate your work and travel with NoiseGuard Pro—where clarity meets comfort.

With just a few lines of code, we’ve created marketing-quality copy that would normally require a professional writer. The function is also reusable — just change the parameters, and you can generate descriptions for any product in your catalog.

This example demonstrates key patterns when using the Responses API:

1. The instructions parameter acts as a system prompt, defining the AI's behavior and context.
2. The temperature parameter (0-2) controls randomness—lower values produce more deterministic outputs while higher values introduce more creativity.
3. The max_output_tokens parameter limits response length, which helps control costs and ensure concise outputs.
4. The response object contains the generated text in the output_text property.

Analyzing images for practical applications

Many real-world applications need to process both text and images. For instance, e-commerce platforms need to analyze product photos, content moderation systems need to review uploads, and social media apps need to understand visual content.

The Responses API excels at multimodal tasks like image analysis without requiring separate endpoints or complex integration code:

def analyze_product_image(image_url):
   response = client.responses.create(
       model="gpt-4o",
       instructions="You are a product photography expert and e-commerce consultant.",
       input=[
           {"role": "user", "content": "Analyze this product image and provide the following details:\n1. Product category\n2. Key visible features\n3. Potential quality issues\n4. Suggested improvements for the product photography"},
           {
               "role": "user",
               "content": [
                   {
                       "type": "input_image",
                       "image_url": image_url
                   }
               ],
           },
       ],
       temperature=0.2
   )
  
   return response.output_text

# Example with a sports team image
analysis = analyze_product_image("https://upload.wikimedia.org/wikipedia/commons/a/a5/Barcelona_fc_lamina_elgrafico.jpg")
print(analysis)

Output:

1. **Product Category**: Sports team memorabilia or vintage sports photography.

2. **Key Visible Features**:
  - The image features a group of individuals in sports uniforms, likely a football (soccer) team.
  - The uniforms have distinct vertical stripes in red and blue.
  - A football is visible in the foreground.
  - The setting appears to be an outdoor field, possibly a stadium.

...

This function could be integrated into an e-commerce platform to automatically analyze product photos when merchants upload them. The system could provide immediate feedback about image quality and suggest improvements, ultimately leading to better conversion rates through higher quality listings — all without manual review.

When working with images, you should pass an array of message objects to the input parameter instead of a string, each with a role and content values.

 Image content is specified as an object with type: input_image and an image_url. You can combine text and images in the same request, enabling rich multimodal interactions.

Implementing streaming for responsive applications

Users expect instant feedback. Waiting several seconds for an AI response can kill engagement — that’s why streaming is essential for creating responsive user experiences, especially in chat or real-time applications.

Imagine you’re building a customer feedback analysis tool for a product team. Instead of making them wait for the complete analysis, you can stream the results as they’re generated:

def analyze_customer_feedback(feedback_text):
   print("Analyzing customer feedback in real-time:")
  
   stream = client.responses.create(
       model="gpt-4o",
       instructions="Extract key sentiments, product issues, and actionable insights from this feedback.",
       input=feedback_text,
       stream=True,
       temperature=0.3,
       max_output_tokens=500
   )
  
   full_response = ""
   print("\nAnalysis results:")
   for event in stream:
       if event.type == "response.output_text.delta":
           print(event.delta, end="")
           full_response += event.delta
       elif event.type == "response.error":
           print(f"\nError occurred: {event.error}")
  
   return full_response

# Example with a complex customer review
feedback = """
I've been using the SmartHome Hub for about 3 months now. The voice recognition is fantastic
and the integration with my existing devices was mostly seamless. However, the app crashes
at least once a day, and the night mode feature often gets stuck until I restart the system.
Customer support was helpful but couldn't fully resolve the app stability issues.
"""

analysis_result = analyze_customer_feedback(feedback)

In a real application, you would replace the print statements with UI updates, allowing your users to see the analysis forming in real-time—much like how modern chat applications show the AI "thinking" as it generates a response. This creates a more engaging experience and gives users immediate feedback that their request is being processed.

The streaming implementation works by:

1. Setting stream=True in the create method
2. Processing the response as an iterable of events with specific types
3. Handling different event types separately: response.output_text.delta for content chunks, response.error for errors

Now that we’ve covered the basic functionality of the Responses API, let’s explore its built-in tools that further enhance its capabilities.

OpenAI Responses API Built-In Tools

The Responses API integrates a few built-in tools that extend its capabilities beyond basic text generation. These tools allow developers to create more powerful applications without the need for complex integration code or multiple API calls.

Web search: accessing real-time information

The web search tool enables the Responses API to retrieve current information from the internet, addressing the limitation of LLMs being restricted to their training data.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
   model="gpt-4o",
   tools=[{"type": "web_search_preview"}],
   input="What are some news related to the stock market?",
)

print(response.output_text)

Output:

Recent developments in the stock market have been significantly influenced by escalating trade tensions between the United States and China. On April 5, 2025, President Donald Trump announced an additional 34% tariff on Chinese goods, raising total tariffs to 54% this year. In response, China imposed reciprocal 34% tariffs on U.S. products and introduced export restrictions on certain rare earth elements. These actions led to a sharp global market selloff, with the S&P 500 falling 9% for the week, marking the steepest decline since the pandemic. (reuters.com)

…..


## Escalating US-China Trade Tensions Impact Global Markets:
- [China says 'market has spoken' after US tariffs spark selloff](https://www.reuters.com/world/china/china-says-market-has-spoken-after-us-tariffs-spark-selloff-2025-04-05/?utm_source=openai)
- [Trump touts "economic revolution" as economists warn of recession](https://www.axios.com/2025/04/05/trump-tariffs-stock-market-recession?utm_source=openai)
- [Believe it or not, there were some winners in the stock market this week](https://apnews.com/article/ce81e9ae6fb463dc763dfaa464778343?utm_source=openai)

The web search tool performs several operations when activated, from analyzing the query to synthesizing information from multiple sources with proper citations. This capability opens up possibilities for information-rich applications such as financial analysis tools that provide market insights, news aggregation platforms that combine multiple sources, or educational resources that supplement core content with current research.

A key benefit of this tool is the ability to provide timely information without needing to build and maintain a custom search integration or web scraping system. The tool handles the search process while presenting results with proper citations to maintain transparency about information sources.

File search: extracting information from documents

While web search brings external knowledge into your application, the file search tool focuses on unlocking information from documents. This tool allows the API to search through and extract information from documents that have been uploaded to OpenAI.

The file search tool enables several key capabilities:

• Searching across multiple file types (PDFs, Word documents, presentations, etc.).
• Finding specific information within documents based on natural language queries.
• Extracting and synthesizing information from multiple documents simultaneously.
• Providing citations to specific sections of the source documents.
• Supporting complex queries that reference information across multiple files.

This capability is well-suited for document analysis use cases such as extracting information from legal contracts, analyzing research papers, or building knowledge bases from technical documentation. The tool can identify relevant sections across multiple documents and synthesize information in response to specific queries.

The implementation requires first uploading files to OpenAI’s files endpoint, then passing the file IDs to the Responses API when making a query. This creates a streamlined workflow for applications that need to reference specific information within documents without requiring users to search manually.

Computer use: interface interaction capabilities

Building on the foundation of text and document understanding, the computer use tool extends AI capabilities into the realm of interface interaction. This tool represents a significant advancement that bridges the gap between language understanding and user interface manipulation.

The computer use tool can perform a variety of interface interactions:

• Navigate websites and web applications autonomously.
• Fill out forms with appropriate information.
• Extract data from web pages and applications.
• Execute multi-step processes across different screens.
• Interact with elements like buttons, dropdowns, and text fields.
• Understand the context and purpose of different interface elements.

Potential applications include process automation for repetitive tasks, guided assistance for complex workflows, and accessibility improvements for users who have difficulty with traditional interfaces. The tool could be used to automate form filling, navigate complex websites, or perform testing of user interfaces.

The technology works by allowing the AI to see and interact with screen elements, understand context, and execute actions based on natural language instructions. This creates possibilities for automation and assistance that would otherwise require specialized development of interface-specific code.

Additional tool capabilities

The tools ecosystem within the Responses API continues to grow, with OpenAI regularly adding new capabilities. The comprehensive tools documentation covers implementation details for all currently available tools, while the article on new tools for building agents provides strategic context on how these tools are evolving.

These built-in tools provide powerful capabilities out of the box, but many applications require connecting to specialized services or proprietary systems. This is where function calling becomes essential, allowing you to extend the Responses API with your own custom tools and external services — the focus of our next section.

Function Calling in the Responses API

While built-in tools provide powerful capabilities, many applications require connecting to specialized services or proprietary systems. Function calling allows you to extend the Responses API with your own custom tools, enabling the model to determine when and how to call your functions based on user input.

Function calling creates a bridge between the AI’s language understanding and your external systems — whether that’s retrieving exchange rates, calculating distances, or checking appointment availability. This pattern follows a clear workflow:

1. You define functions that the AI can use, specifying parameters and their types.
2. The AI decides when to call these functions based on user queries.
3. Your code executes the functions with the AI-provided parameters.
4. You return the results to the AI, which incorporates them into its response.

Creating a currency conversion tool

Let’s implement a simple currency conversion function as an example:

# Dictionary of exchange rates (relative to USD)
exchange_rates = {
   "USD": 1.0,
   "EUR": 0.93,
   "GBP": 0.79,
   "JPY": 153.2,
   "CAD": 1.37,
   "AUD": 1.52
}

def convert_currency(amount, from_currency, to_currency):
   """Convert an amount from one currency to another."""
   # Normalize currency codes to uppercase
   from_currency = from_currency.upper()
   to_currency = to_currency.upper()
  
   # Check if currencies are supported
   if from_currency not in exchange_rates:
       return {"error": f"Currency not supported: {from_currency}"}
   if to_currency not in exchange_rates:
       return {"error": f"Currency not supported: {to_currency}"}
  
   # Convert to USD first, then to target currency
   amount_in_usd = amount / exchange_rates[from_currency]
   converted_amount = amount_in_usd * exchange_rates[to_currency]
  
   return {
       "original_amount": amount,
       "from_currency": from_currency,
       "to_currency": to_currency,
       "converted_amount": round(converted_amount, 2)
   }

This function takes three parameters: the amount to convert, the source currency, and the target currency. It performs a simple conversion using predefined exchange rates and returns a structured result with the conversion details.

Defining the function for the Responses API

Now, we need to tell the model about our function so it can decide when to call it:

from openai import OpenAI
import json

client = OpenAI()

tools = [
   {
       "type": "function",
       "name": "convert_currency",
       "description": "Convert an amount from one currency to another using current exchange rates",
       "parameters": {
           "type": "object",
           "properties": {
               "amount": {
                   "type": "number",
                   "description": "The amount of money to convert"
               },
               "from_currency": {
                   "type": "string",
                   "description": "The currency code to convert from (e.g., USD, EUR, GBP)"
               },
               "to_currency": {
                   "type": "string",
                   "description": "The currency code to convert to (e.g., USD, EUR, GBP)"
               }
           },
           "required": ["amount", "from_currency", "to_currency"],
           "additionalProperties": False
       },
       "strict": True
   }
]

This definition clearly specifies:

• The function name convert_currency that matches our Python function.
• A description that explains when the function should be used.
• Three required parameters with their types and descriptions.
• The strict: true flag to ensure the model follows our parameter specifications exactly.

Handling a user query

Let’s simulate a conversation where a user asks about currency conversion:

input_messages = [
   {"role": "user", "content": "How much is 100 euros in Japanese yen?"}
]

response = client.responses.create(
   model="gpt-4o",
   input=input_messages,
   tools=tools,
)

When the model sees this question about currency conversion, it recognizes it should use our function. It automatically identifies that:

• The amount is 100
• The source currency is euros (EUR)
• The target currency is Japanese yen (JPY)

Processing the function call

Now we extract the function call details and execute our function:

tool_call = response.output[0]
print(f"Function called: {tool_call.name}")
print(f"Arguments: {tool_call.arguments}")

args = json.loads(tool_call.arguments)

# Execute the function with the parameters determined by the model
conversion_result = convert_currency(**args)
print(f"Function results: {conversion_result}")

The model has translated the natural language query into structured parameters. Our function then performs the calculation based on these parameters and returns the converted amount.

Returning function results to the model

Finally, we send the results back to the model so it can generate a user-friendly response:

input_messages.append(tool_call)  # append model's function call message
input_messages.append(
   {  # append result message
       "type": "function_call_output",
       "call_id": tool_call.call_id,
       "output": json.dumps(conversion_result)
   }
)

response_2 = client.responses.create(
   model="gpt-4o",
   input=input_messages,
   tools=tools,
)
print(response_2.output_text)

Output:

100 euros is equal to 16,473.12 Japanese yen based on current exchange rates.

The model has taken our raw conversion data and transformed it into a natural, human-readable response. It correctly interpreted the numerical result and presented it in an appropriate format for currency.

Putting everything together

In a real application, you’ll want to encapsulate this entire process into a single interface that handles the conversation flow seamlessly. Here’s how you might create a complete assistant that manages the entire function calling process:

def currency_assistant(user_message, conversation_history=None):
   """A complete assistant that handles currency conversion queries."""
   if conversation_history is None:
       conversation_history = []
  
   # Add the user's new message to the conversation
   conversation_history.append({"role": "user", "content": user_message})
  
   # Define available tools (our currency conversion function)
   tools = [{
       "type": "function",
       "name": "convert_currency",
       "description": "Convert an amount from one currency to another using current exchange rates",
       "parameters": {
           "type": "object",
           "properties": {
               "amount": {
                   "type": "number",
                   "description": "The amount of money to convert"
               },
               "from_currency": {
                   "type": "string",
                   "description": "The currency code to convert from (e.g., USD, EUR, GBP)"
               },
               "to_currency": {
                   "type": "string",
                   "description": "The currency code to convert to (e.g., USD, EUR, GBP)"
               }
           },
           "required": ["amount", "from_currency", "to_currency"],
           "additionalProperties": False
       },
       "strict": True
   }]
  
   # Get initial response from the model
   response = client.responses.create(
       model="gpt-4o",
       input=conversation_history,
       tools=tools,
   )
  
   # Check if the model wants to call a function
   if response.output and isinstance(response.output, list) and response.output[0].type == "function_call":
       tool_call = response.output[0]
      
       # Process the function call
       args = json.loads(tool_call.arguments)
       result = convert_currency(**args)
      
       # Add the function call and its result to the conversation
       conversation_history.append(tool_call)
       conversation_history.append({
           "type": "function_call_output",
           "call_id": tool_call.call_id,
           "output": json.dumps(result)
       })
      
       # Get the final response with the function results incorporated
       final_response = client.responses.create(
           model="gpt-4o",
           input=conversation_history,
           tools=tools,
       )
      
       return final_response.output_text, conversation_history
   else:
       # If no function call was needed, return the direct response
       return response.output_text, conversation_history

# Example usage
response, conversation = currency_assistant("How much is 50 British pounds in Australian dollars?")
print("Assistant:", response)

# Continue the conversation
response, conversation = currency_assistant("And what if I wanted to convert 200 Canadian dollars instead?", conversation)
print("Assistant:", response)

This implementation:

1. Maintains conversation history to provide context for follow-up questions.
2. Handles the entire process of function calling in a single interface.
3. Determines when function calling is necessary and when the model can respond directly.
4. Supports multi-turn conversations where previous context matters.

With this approach, you can create seamless conversational experiences where users interact naturally without being aware of the complex function calling happening behind the scenes. The assistant handles the transition between natural language understanding, structured function calls, and natural language generation.

Building more complex applications might involve:

1. Supporting multiple functions, each for different types of queries.
2. Managing authentication and authorization for sensitive operations.
3. Implementing more sophisticated error handling and recovery.
4. Adding logging and monitoring for function usage and performance.
5. Creating user interfaces that support text, voice, or multimodal interactions.

Function calling enables the Responses API to connect natural language inputs with your services and data. This creates a bridge between user requests and your business systems, allowing users to make requests in plain language while your application handles the technical implementation details in the background.

Beyond function calling, another powerful capability of the Responses API is the ability to generate structured outputs. This feature complements function calling by providing a way to receive responses in specific formats that align with your application’s needs.

Structured Outputs With the Responses API

When building AI applications, you often need responses in a specific format for easier integration with your systems. The Responses API supports structured outputs that enable you to receive data in a well-defined, consistent format rather than free-form text. This feature is particularly valuable when you need to:

1. Extract specific information from unstructured text.
2. Transform user inputs into structured data.
3. Ensure consistent response formats for downstream processing.
4. Integrate AI outputs directly with databases or APIs.

Structured outputs reduce the need for additional parsing and validation, making your applications more robust and easier to maintain.

Extracting product information from descriptions

Let’s explore a practical example: imagine you’re building an e-commerce platform and need to automatically extract product details from unstructured product descriptions to populate your database.

from openai import OpenAI
import json

client = OpenAI()

product_description = """
Our Premium Laptop Backpack is perfect for professionals and students alike.
Made with water-resistant material, it features padded compartments that fit
laptops up to 15.6 inches. The backpack includes 3 main storage areas,
5 smaller pockets, and has an integrated USB charging port. Available in
navy blue, black, and gray. Current retail price: $79.99, though it's
currently on sale for $64.99 until the end of the month.
"""

response = client.responses.create(
   model="gpt-4o",
   input=f"Extract structured product information from this description: {product_description}",
   text={
       "format": {
           "type": "json_schema",
           "name": "product_details",
           "schema": {
               "type": "object",
               "properties": {
                   "product_name": {"type": "string"},
                   "category": {"type": "string"},
                   "features": {"type": "array", "items": {"type": "string"}},
                   "colors": {"type": "array", "items": {"type": "string"}},
                   "pricing": {
                       "type": "object",
                       "properties": {
                           "regular_price": {"type": "number"},
                           "sale_price": {"type": "number"},
                           "currency": {"type": "string"},
                       },
                       "additionalProperties": False,
                       "required": ["regular_price", "sale_price", "currency"],
                   },
               },
               "required": ["product_name", "features", "colors", "pricing","category"],
               "additionalProperties": False,
           },
           "strict": True,
       }
   },
)

product_data = json.loads(response.output_text)
print(json.dumps(product_data, indent=2))

Output:

{
 "product_name": "Premium Laptop Backpack",
 "category": "Backpack",
 "features": [
   "Water-resistant material",
   "Padded compartments for laptops up to 15.6 inches",
   "3 main storage areas",
   "5 smaller pockets",
   "Integrated USB charging port"
 ],
 "colors": [
   "Navy blue",
   "Black",
   "Gray"
 ],
 "pricing": {
   "regular_price": 79.99,
   "sale_price": 64.99,
   "currency": "USD"
 }
}

This formatted JSON data can now be directly integrated with your product database, eliminating the need for custom parsing logic and reducing the chance of errors.

Understanding the structured output configuration

The key to effective and error-free structured outputs is properly defining your schema. Let’s break down the important elements of the configuration:

text={
   "format": {
       "type": "json_schema",        # Specifies we're using JSON Schema
       "name": "product_details",    # A descriptive name for this schema
       "schema": {
           # Your JSON Schema definition here
           "type": "object",
           "properties": {
               # Each property with type information, e.g.
               "product_name": {"type": "string"},
               # ... other properties
           },
           "required": ["product_name", ...], # All other properties
           "additionalProperties": False
       },
       "strict": True                # Enforce schema constraints strictly
   }
}

The most important components are:

1. Schema definition: Describes the structure, including all properties and their types.
2. Required fields: Lists properties that must be included in the response.
3. Additional properties: When set to False, prevents extra fields not defined in the schema.
4. Strict mode: When True, ensures the model follows the schema precisely.

Practical tips for using structured outputs

For best results with structured outputs, follow these guidelines:

1. Design your schema carefully: Include all required fields but keep it focused on essential information.
2. Use appropriate data types: Match your schema types to how you’ll use the data (numbers for calculations, strings for text).
3. Set clear constraints: Use enum for fields with limited options and minimum/maximum for numerical boundaries.
4. Test with varied inputs: Ensure your schema handles different input formats and edge cases.
5. Include clear descriptions: Adding descriptions to fields helps the model interpret what information to extract.

Comparing with Chat Completions API

While the Responses API provides structured outputs through JSON Schema, the Chat Completions API offers an alternative approach using Pydantic models that is much simpler:

from pydantic import BaseModel, Field
from typing import List, Optional
from openai import OpenAI

client = OpenAI()

class ProductDetails(BaseModel):
   product_name: str
   category: str = Field(default=None)
   features: List[str]
   specifications: Optional[dict] = None
   colors: List[str]
   pricing: dict

# With Chat Completions API
completion = client.beta.chat.completions.parse(
   model="gpt-4o",
   messages=[
       {"role": "system", "content": "Extract structured product information."},
       {"role": "user", "content": product_description}
   ],
   response_format=ProductDetails
)

pydantic_product = completion.choices[0].message.parsed

Each approach has benefits:

• Responses API uses standard JSON Schema directly in the API call
• Chat Completions API integrates with Python’s type system through Pydantic

If you ask me, I would use the Chat Completions API so that I can avoid writing raw JSON schemas. That is until, of course, OpenAI adds support for Pydantic models to the Responses API.

For more information, see the Responses API documentation for Structured Outputs.

Conclusion

The OpenAI Responses API simplifies how developers interact with language models by combining previous APIs’ strengths into a unified interface that requires less code and complexity. It supports text generation, image analysis, function calling, and structured outputs, making AI capabilities more accessible while allowing developers to focus on solving business problems instead of integration challenges.

As you continue your journey with the Responses API, you might find these additional resources helpful for deepening your understanding and expanding your implementation skills:

• Working with the OpenAI API
• OpenAI Fundamentals Track
• GPT-4.5: What’s New in OpenAI’s Latest Model
• Deep Research with OpenAI
• GPT-4.5 Function Calling Tutorial
• GPT-4.5 API Tutorial
• OpenAI Agents SDK Tutorial