JSON to OpenAI Function: Generate Function Calling Schemas Instantly

JSON to OpenAI Function: Generate Function Calling Definitions from JSON Payloads

OpenAI's function calling (now called "tools") lets GPT-4 and other models invoke structured operations with validated parameters. Every tool definition requires a JSON Schema describing its parameters — writing this by hand for every endpoint is repetitive and easy to get wrong. TypeMorph infers the schema from a real JSON sample and generates a complete, ready-to-use OpenAI function definition.

Live Example: From JSON to OpenAI Function Definition

// Input JSON (a sample payload)
{
  "user_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "email": "[email protected]",
  "amount": 9900,
  "currency": "USD",
  "is_recurring": false
}

// Generated OpenAI Function Definition
{
  "type": "function",
  "function": {
    "name": "root",
    "description": "Processes root data — update with a meaningful description",
    "parameters": {
      "type": "object",
      "properties": {
        "user_id": { "type": "string", "format": "uuid", "description": "UUID identifier for the user" },
        "email": { "type": "string", "format": "email", "description": "Email address" },
        "amount": { "type": "integer", "minimum": 0, "description": "Monetary amount" },
        "currency": { "type": "string", "description": "Currency code" },
        "is_recurring": { "type": "boolean", "description": "Whether this is recurring" }
      },
      "required": ["user_id", "email", "amount", "currency", "is_recurring"]
    }
  }
}

Step-by-Step Integration

1. Paste your JSON into TypeMorph and select OpenAI Function as the output format.
2. Update the function name and description — use a verb-noun name like createPayment and write a clear description so the model knows when to call this function.
3. Pass to the API in the tools array of your chat completion request.
4. Handle the response: When the model returns a tool_calls message, parse JSON.parse(toolCall.function.arguments) and execute your logic.
5. Return the result back to the model as a tool message for multi-step reasoning.

Technical Deep Dive: JSON Schema vs Zod for Function Calling

OpenAI's API accepts raw JSON Schema for tool parameters, not Zod. TypeMorph generates the correct JSON Schema format with semantic constraints inferred from field names: email fields get "format": "email", UUID fields get "format": "uuid", monetary amounts get "minimum": 0, and age fields get "minimum": 0, "maximum": 150. These hints help the model produce valid values rather than hallucinating formats. For structured outputs (JSON mode), you can use the same schema in the response_format parameter with "strict": true.

Structured Outputs (Strict Mode)

OpenAI's structured outputs feature enforces that the model always returns valid JSON matching your schema. To use it, add "strict": true and ensure every object has "additionalProperties": false:

const response = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: [...],
  response_format: {
    type: "json_schema",
    json_schema: {
      name: "payment_schema",
      strict: true,
      schema: { ...generatedSchema, additionalProperties: false }
    }
  }
});

Best Practices

• Use descriptive function names: The model picks functions by name and description. createInvoice is better than process.
• Add enum constraints for known values: If a field can only be "USD", "EUR", or "JPY", add "enum": ["USD", "EUR", "JPY"] to eliminate invalid outputs.
• Keep required fields minimal: Only mark fields as required if the function cannot run without them. Optional fields give the model flexibility.
• Validate before executing: Even with function calling, validate the parsed arguments with Zod or another validator before passing them to your business logic.

FAQ

Q: What's the difference between function calling and structured outputs?
A: Function calling lets the model decide when to invoke a function and what arguments to pass. Structured outputs (JSON mode) always return JSON matching a schema — it's for extracting structured data from model responses, not triggering actions.

Q: Can I use this with other providers like Anthropic or Mistral?
A: Most LLM providers support OpenAI-compatible tool definitions. Anthropic's tool use format is nearly identical but uses input_schema instead of parameters. The generated JSON Schema is directly reusable with minor renaming.

Q: How do I handle nested objects in function parameters?
A: TypeMorph generates nested {"type": "object", "properties": {...}} for nested JSON objects. OpenAI's strict mode requires these to also have "additionalProperties": false.