Required vs. optional fields in ChatGPT apps

January 27, 2026·MB Samuel

Nearly 1 in 5 tools in the ChatGPT App Store don't mark any of their fields as required. That means when a user says "search for apartments in Brooklyn," ChatGPT has no way of knowing whether the location field is mandatory or just a nice-to-have. It either guesses (and risks sending an incomplete request) or asks the user a string of clarifying questions it shouldn't need to ask.

We analyzed 3,349 parameters across 687 tools in 147 third-party ChatGPT apps to understand how developers are handling the required-versus-optional distinction. The short version: there's a striking bimodal pattern where most tools either require everything or require nothing, and both extremes create real problems.

The Big Picture: A Bimodal Distribution

Across all 687 tools that accept input parameters, here's how the required-field ratio breaks down:

Required Ratio	Tools	Share
0% (nothing required)	131	19.1%
1-25%	88	12.8%
26-50%	132	19.2%
51-75%	43	6.3%
76-99%	6	0.9%
100% (everything required)	287	41.8%

The distribution is bimodal. The two largest buckets are at opposite extremes: 41.8% of tools mark every single field as required, while 19.1% mark nothing as required. The middle ground (26-75% required) accounts for only 25.5% of tools. The median required ratio across all tools is 0.50, and the average is 0.57, but those summary statistics mask the fact that most tools cluster at the poles rather than the center.

This pattern suggests that many developers are either defaulting to "require everything" (which is what happens when you list all fields in the JSON Schema required array without thinking about it) or "require nothing" (which is what happens when you omit the required array entirely). Neither extreme reflects a thoughtful decision about which fields the AI model actually needs to make a valid request.

The "Everything Required" Pattern: 287 Tools

The largest single bucket is tools that mark 100% of their fields as required. In many cases this makes sense. A tool with 1 or 2 fields (like a simple search query or a lookup by ID) genuinely needs all of them. If Zillow's interestRateMortgagePaymentSimulator requires a loan amount, interest rate, loan term, home price, down payment, and zip code, all six fields really are necessary to produce a meaningful calculation.

But the pattern breaks down with complex tools. Consider these tools where every field is marked required:

App	Tool	Required Fields
Jotform	`search`	14
Jobkorea	`jobkorea_job_search`	14
Intuit TurboTax	`tax_expert_connect.book_appointment`	12
Retell AI	`generate_prompt`	7
Zillow	`calculateHomeAffordability`	7

When Jobkorea marks all 14 fields on its job search tool as required, ChatGPT must provide every one of them before it can make the call. If a user says "find me marketing jobs in Seoul," the model either has to ask the user about 12 additional fields (salary range, experience level, employment type, company size, and so on), or it has to fabricate values for fields the user never mentioned. Neither outcome is good. The first creates a frustrating interrogation. The second risks sending the API a request full of hallucinated values that silently filter out relevant results.

The sweet spot for the "everything required" approach is tools with a small number of genuinely essential fields. Zillow makes this work for interestRateMortgagePaymentSimulator (6 required fields, all necessary for the math) and calculateHomeAffordability (7 required fields, same logic). These are calculators where every input changes the output. But for search and discovery tools, where many fields are filters that narrow results, marking everything as required creates unnecessary friction.

The "Nothing Required" Pattern: 131 Tools

On the other end, 131 tools (19.1%) don't mark any fields as required. Some of the most extreme examples:

App	Tool	Total Fields
Zumper	`search_rentals`	43
Insurify	`compare_car_insurance_rates`	37
Trade Me Property	`search_residential_properties`	31
leboncoin	`search_real_estate_sales`	30
Conductor	`ai_brands_marketshare`	22

Zumper's rental search tool has 43 fields and none of them are required. That means ChatGPT could, in theory, call this tool with an empty request body. It probably won't (the model is smart enough to send at least a location), but the metadata provides no guidance about what's essential.

The risk here is subtle. When nothing is marked required, ChatGPT has to infer importance from field names, descriptions, and the user's request. It usually does a reasonable job, but it's working harder than it needs to, and the failure mode is sending too few fields rather than too many. A rental search with only a city but no price range, bedroom count, or move-in date is technically valid but practically useless.

At the app level, 15 apps have zero required fields across all their tools. The most notable:

App	Category	Total Params
Conductor	Business	43
Insurify	Shopping	37
Trade Me Property	Lifestyle	32
WeightWatchers	Food	25
Kleinanzeigen	Shopping	11

These aren't small apps with a single field. Conductor has 43 parameters across 2 tools and none of them are required. Insurify has 37 parameters for comparing car insurance rates, a workflow that inherently requires information like vehicle type and zip code, but nothing is marked as mandatory in the metadata.

Category Patterns: Who Requires More?

The required-field ratio varies meaningfully by category:

Category	Required %	Params	Apps
Entertainment	53.6%	28	3
Developer Tools	52.6%	274	10
Productivity	49.2%	502	18
Design	43.4%	106	5
Education	42.6%	47	8
Business	36.5%	397	22
Finance	36.2%	621	18
Collaboration	32.7%	297	4
Lifestyle	29.7%	327	21
Food	27.5%	131	6
Travel	18.4%	158	13
Shopping	13.4%	433	14

Developer Tools and Productivity apps have the highest required ratios (53% and 49%), which makes sense. Developer tools often perform specific operations (deploy a site, create a project, run a query) where the inputs are well-defined and genuinely necessary. Productivity apps like Jotform, Monday.com, and Airtable tend to have structured create and update operations where key identifiers and values are always needed.

Shopping and Travel apps sit at the opposite end (13% and 18%). These categories are dominated by search tools with many optional filters. When you search for flights or products, only a few fields are truly essential (origin, destination, dates for flights; a search query for products), and everything else (price range, brand, number of stops) is an optional refinement. The low required ratios reflect the filter-heavy nature of these tools.

The interesting gap is Finance at 36%. Finance apps span both patterns. Calculators and transaction tools (like Zillow's mortgage tools or Stripe's payment links) tend to require most of their fields. But data retrieval tools (like S&P Global's market data queries or Ramp's expense lookups) lean heavily optional. The blended category rate obscures this internal variation.

Apps That Get the Balance Right

The best-balanced apps tend to have required ratios between 40% and 60%, reflecting a deliberate split between "what the tool needs to function" and "what can refine the results."

App	Category	Required	Total	Ratio
PitchBook	Finance	22	44	50.0%
Klaviyo	Productivity	91	184	49.5%
S&P Global	Finance	26	53	49.1%
Replit	Developer Tools	24	49	49.0%
Figma	Design	17	35	48.6%
Gusto	Finance	52	99	52.5%
Adobe Acrobat	Business	30	57	52.6%
Airtable	Productivity	19	35	54.3%

These apps have enough fields to create a meaningful distinction between "must have" and "nice to have." PitchBook, for example, has 44 parameters across 12 tools with exactly half marked required. Its financial data queries need a company identifier or search term (required) but allow optional filters for date ranges, data types, and result limits.

Klaviyo is particularly interesting because it's one of the largest apps in the dataset (184 parameters across 26 tools) and still maintains a near-50% required ratio. Every tool requires a model parameter (identifying which LLM is calling the tool) and the core entity identifier, while pagination, sorting, field selection, and filters are all optional. This is a clean pattern: require the minimum needed to make a valid request, and leave everything else for the model to fill in from context.

The "Over-Requiring" Problem

We identified 37 apps with 10 or more required fields. The sheer volume of required fields in some of these apps raises questions about whether every requirement is intentional:

App	Required	Total	Required %
Jam	28	31	90.3%
Adobe Express	17	20	85.0%
Quizlet	10	12	83.3%
Statsig	11	12	91.7%
Jotform	26	26	100.0%

Jam (a bug-reporting tool for developers) requires 28 out of 31 fields. That's a 90% required ratio across what are likely bug report submissions and lookups. Statsig requires 11 of 12 fields (92%). At these levels, the distinction between "required" and "optional" barely exists, which raises the question of whether these apps are using the required field as an intentional signal or simply defaulting to marking everything.

What Does This Mean in Practice?

The required-field distinction in your tool's JSON Schema is one of the most direct signals you can give ChatGPT about how to use your app. When it works well:

Required fields tell the model what it absolutely must collect (from the user or from context) before calling the tool. The model will ask the user for these if it can't infer them.
Optional fields tell the model what it can include to improve results but should not block on. The model will fill these in if the user mentions them but won't ask about them unprompted.

When the signal is missing or miscalibrated, two things happen. If everything is required, the model either interrogates the user for information they didn't offer or hallucinate values for fields it has no basis to fill. If nothing is required, the model may send underspecified requests that return overly broad or irrelevant results.

A Practical Framework for Deciding What's Required

Based on the patterns we've seen across 147 apps, here's a framework for deciding which fields to mark as required:

Mark a field as required if:

The tool literally cannot function without it (a search query, an entity ID, a calculation input)
Omitting it would return an error from your API
The field represents the core intent of the tool call (what the user is looking for, what entity they're acting on)

Mark a field as optional if:

It narrows or refines results but isn't necessary for a valid response (filters, sort orders, date ranges)
It has a sensible default your API can fall back on (page size, result limit, output format)
It represents a preference rather than a requirement (price range, rating threshold, language)

Common mistakes to avoid:

Marking pagination fields (page, limit, cursor) as required. These should almost always be optional with sensible defaults.
Marking every filter on a search tool as required. If a user says "find me a hotel in Paris," they shouldn't need to specify star rating, price range, and amenity preferences before the search can run.
Omitting the required array entirely. Even if your API handles empty requests gracefully, the missing signal makes ChatGPT's job harder.

Methodology

This analysis covers 147 third-party apps in the ChatGPT App Store as of February 2025. We excluded integrations built and maintained by OpenAI (like GitHub, Linear, Slack, and Google Workspace) to focus on apps that companies built and shipped independently. Of the 886 total tools across these apps, 687 accept input parameters (totaling 3,349 individual parameters). The remaining 199 tools have no parameters. Required-field designations were extracted from each tool's JSON Schema required array.

Want access to the full dataset? Contact us to learn more.