Pydantic Model Responses API

API
1

How do you use Pydantic models in the Responses API?

I’ve been trying to follow this:
https://platform.openai.com/docs/guides/structured-outputs?api-mode=responses&example=structured-data

import json
from pydantic import BaseModel
from textwrap import dedent
from openai import OpenAI

client = OpenAI()

MODEL = "gpt-4o-mini"
math_tutor_prompt = '''
    You are a helpful math tutor. You will be provided with a math problem,
    and your goal will be to output a step by step solution, along with a final answer.
    For each step, just provide the output as an equation use the explanation field to detail the reasoning.
'''

class MathReasoning(BaseModel):
    class Step(BaseModel):
        explanation: str
        output: str

    steps: list[Step]
    final_answer: str

question = "how can I solve 8x + 7 = -23"

response = client.responses.parse(
    model=MODEL,
    instructions=math_tutor_prompt,
    input=question,
    text= MathReasoning,
)

How do I get this to work? I’ve tried MathReasoning.model_json_schema() too

2

I got this working by passing my Pydantic class to the text_format arg. So in your case:

response = client.responses.parse(
    model=MODEL,
    instructions=math_tutor_prompt,
    input=question,
    text_format= MathReasoning,
)
1 Like
3

There’s no such parameter:
Responses.create() got an unexpected keyword argument 'text_format'

In chat completions, you simply send into client.beta.chat.completions.parse():

response_format=MathReasoning

I tried every nest level within this new structure for response format:

  text={
    "format": {
      "type": "json_schema",
      "name": "math_reasoning",
      "strict": True,
      "schema": MathReasoning
    }
  },

It appears that just like the API reference for “Structured data extraction” will readily switch between Pydantic and JSON when you select between endpoints, there is also no Python SDK stream parser for BaseModel, even if you start guessing:

'Beta' object has no attribute 'responses'

=—=

Try:

See your schema.
print(json.dumps(myBaseModel.model_json_schema(), indent=3))

tag on to every class:
model_config = ConfigDict(extra='forbid')

Send json.

4

You need to use responses.parse, not responses.create

1 Like
5

Thanks for that! Looks like one has to go over to github and start digging…(I was one unnecessary .beta away…)

Also:

>>>response.output_parsed.__class__
<class '__main__.MathReasoning'>

>>>print(response.output_parsed)

steps=[Step(explanation='The problem asks us to add 275 and 145. Start by lining up the numbers by their place value:', output=' 275\n+145'), Step(explanation='Add the digits in the units column (5 + 5 = 10). Write down 0 and carry over 1 to the tens column.', output=' 275\n+145\n-----\n 0 (carry 1)'), Step(explanation='Add the digits in the tens column, including the carry-over (7 + 4 + 1 = 12). Write down 2 and carry over 1 to the hundreds column.', output=' 275\n+145\n-----\n 20 (carry 1)'), Step(explanation='Add the digits in the hundreds column (2 + 1 + 1 = 4).', output=' 275\n+145\n-----\n 420')] final_answer='420'

1 Like
6

Sample here:

1 Like
7

Asking chatGPT to correct my code, it removed the {"role": "developer", "content" in calling responses.parse()

here what it said, which is new for me - is that true?:

You can’t give a developer message to responses.parse().
Developer messages are only used with responses.create().

responses.create(...)

  • Accepts a list of messages (like Chat API).
  • Supports roles like "user", "system", and "developer".
  • You can include a developer message to provide persistent or contextual instructions.
responses.create(
    model="gpt-4o",
    instructions="Only respond in English.",
    input=[
        {"role": "developer", "content": "Explain answers step by step."},
        {"role": "user", "content": "Solve 8x + 31 = 2"}
    ]
)

This is where developer messages matter.

responses.parse(...)

  • Designed for structured parsing of a single user input string.
  • Does not support developer/system messages or full message lists.
  • The only context you can pass is via:
    • instructions (one-off system-level instruction)
    • text_format (to parse output into a schema)
responses.parse(
    model="gpt-4o",
    instructions="Explain your steps.",
    input="Solve 8x + 31 = 2",
    text_format=MathResponse
)

Developer messages are ignored here — you must instead pass any guidance through instructions.

En plus de ça, responses.parse() does not handle previous_response_id.

8

The AI may give incorrect answers or claim to know things it cannot actually know. For example, ChatGPT often provides outdated or incorrect API code methods. Do not rely on ChatGPT to correct or update your API code. ChatGPT tends to reuse old information and rewrite outdated examples, as shown below in this image:

Example of outdated API provided by ChatGPT
Example of outdated API provided by ChatGPT729×418 9.84 KB

Because of this, avoid sending ChatGPT questions about OpenAI APIs or any other APIs that have changed or been updated in the last two years. ChatGPT does not have current knowledge about these recent changes. The only way ChatGPT could possibly provide accurate information is if you paste the entire repository’s current usage into your question. Even then, ChatGPT will still respond as if your provided code is hypothetical, not actual.

"developer" role is for reasoning AI

You can put back “developer”, as it is the “authority” role name for reasoning models. The API allows it for for most other models, auto-converting in the backend. We can auto-convert ourselves just in case:

developer_input = "JSON output strings: maximum 80 characters."
user_input="List closest relatives to Mandrill monkeys, descending"
# - variables for your Responses endpoint API call
model = "o3-mini"
input=[
    {
      "role": "role": "developer" if model.startswith("o") else "system",
      "content": [
        {
          "type": "input_text",
          "text": developer_input
        }
      ]
    },
    {
      "role": "user",
      "content": [
        {
          "type": "input_text",
          "text": user_input
        }
      ]
    }
]

From sending that to parse(), along with the text_format=ExpertResponse parameter with my BaseModel, we need a “scanner” to get the plain content.text out of all output items received back:

Content found at output index: 1
{
  "topic": "Mandrill relatives taxonomy",
  "chat_title_four_words": "Mandrill Relative Descending Order",
  "output_fulfillment_intro": "# Analysis Answer",
  "complete_answer": "Closest is the drill (Mandrillus leucophaeus); next are baboons; then mangabeys & macaques."
}

But we don’t need the “content”. We want to employ the “parsed” added by the SDK.

How “parsed” is the JSON in the response object? I can employ directly:

print(
    "-" * 40,
    f"\n{response.output_parsed.topic} - "
    f"{response.output_parsed.chat_title_four_words}\n"
    f"{response.output_parsed.output_fulfillment_intro}\n"
    f"{response.output_parsed.complete_answer}\n"
)

Mandrill relatives taxonomy - Mandrill Relative Descending Order

Analysis Answer

Closest is the drill (Mandrillus leucophaeus); next are baboons; then mangabeys & macaques.

The complete_answer would be much longer if not for the developer instruction.

1 Like