The OpenAI Chat Model sub-node (LmChatOpenAi) is the primary
interface for integrating GPT-4o, GPT-4o-mini, and all OpenAI chat models
into n8n workflows. It connects to the AI Agent node as a Language Model
provider, authenticates via API key (stored with AES‑256‑CBC encryption), and
dynamically loads models available to your account. The node exposes
Temperature (0–2, default 1) to control randomness,
Maximum Number of Tokens to cap response length (up to
32,768 tokens for GPT-4o), Response Format (Text, JSON
Schema, or JSON Object), Frequency Penalty (−2.0 to 2.0),
Presence Penalty (−2.0 to 2.0), system messages to define
assistant behavior, and a configurable Timeout with
Max Retries for production resilience [1]
[2].

How do you configure OpenAI credentials and select the optimal GPT-4o model in n8n?

Navigate to Settings → Credentials → New Credential,
select OpenAI API, and paste your API key from
platform.openai.com/api-keys. n8n encrypts the key with AES‑256‑CBC
and stores it as an encrypted password field. For OAuth2 users, a
community draft PR adds access-token support alongside existing API
key authentication, enabling usage with ChatGPT Plus subscriptions.
Once saved, add an AI Agent or Basic LLM Chain root node, attach an
OpenAI Chat Model sub-node, and select gpt-4o from the
dynamically-loaded Model dropdown.
[1]
[4]

For high-volume content generation pipelines, begin prototyping with
gpt-4o-mini ($0.15 per 1 M input tokens) — its lower
cost and faster response times allow rapid iteration. Switch to full
gpt-4o only when output quality from the mini variant
is unacceptable. The Model dropdown displays only models available to
your specific API account; if a model is missing, verify your key has
the model:read scope and check platform.openai.com/usage
for any account-level restrictions. For production credential
management, use a dedicated OpenAI API key scoped to the specific
models your workflows require, and rotate keys every 90 days. For
the complete credential security reference, see the
n8n Credential Nodes guide.

How do you craft effective system messages, user prompts, and assistant roles in the n8n OpenAI node?

The OpenAI Chat Model node supports three message roles that form a
conversation structure. The System message defines
persistent behavioral instructions — the agent’s personality, rules,
output format constraints — and cannot be overridden by subsequent
user inputs. The User message carries the actual
query, task, or data to process. The Assistant
message provides example responses, establishes tone, or supplies
context from prior turns. Messages are constructed as a collection
of role‑content pairs.
[6]
[3]

For system prompts defining the agent’s operational constraints,
include the agent persona description, the task’s scope (e.g., “You
classify support emails into billing, technical, account, or general
categories”), output format instructions (e.g., “Respond ONLY in valid
JSON with keys for category, urgency, and summary”), and explicit
guardrails (e.g., “If uncertain, set urgency to ‘low’ and state
uncertainty in the summary”). In n8n’s AI Agent, access the system
message by clicking “Add Option” at the bottom of the agent
configuration panel and selecting “System Message” from the dropdown.
The system message is processed before every user interaction and
remains fixed throughout the conversation, while the user message
changes with each input. For the complete prompt engineering
framework with six real‑world examples ranging from basic chat to
multi‑step orchestration, see the
n8n OpenAI Prompt Chain Tutorial.

How do you parse GPT-4o outputs into structured JSON and validate the response schema?

The OpenAI Chat Model node supports three response formats: Text
(free-form natural language), JSON Object (guarantees
valid JSON output from the model), and JSON Schema
(enforces a user-defined JSON schema so the model output conforms
exactly to the specified structure). For production automation, always
use JSON Schema or JSON Object — never rely on parsing free-text
responses, which can vary in format and break downstream nodes.
[1]
[7]

For Basic LLM Chain users, add a Structured Output Parser
sub-node — it handles schema enforcement automatically without
touching the Options panel. For Code‑node–based parsing, extract the
response content via
$json.choices[0].message.content, parse with
JSON.parse() inside a try‑catch block, and return the
structured object. The community n8n-nodes-openai-structured-outputs
node provides an alternative Extract JSON operation that accepts an
arbitrary JSON schema and unstructured text, then returns structured
JSON validated against that schema. The key prescription: instruct
the model in the system message to respond “ONLY in valid JSON” with
explicit field names and types, then validate the output schema with
a Code or Output Parser node before downstream consumption. For
production, add a fallback Code node that catches JSON parsing failures
and retries the OpenAI call with a clarified prompt. For the complete
output parsing reference, see the
n8n Code Node Transformation guide.

How do you build a multi-step prompt chain with sequential GPT-4o calls in n8n?

A prompt chain connects multiple AI Agent or Basic LLM Chain nodes in
sequence, where each node’s output feeds the next node’s input. The
canonical three‑stage chain for content generation: Stage 1 –
Outline: an OpenAI node generates a 5‑section article
outline; Stage 2 – Write: a Set node extracts the
outline text and feeds it into a second OpenAI node that writes the
full article; Stage 3 – Evaluate: a third OpenAI
node scores the draft against SEO and readability criteria.
[8]
[9]

For branching chains, insert an IF node after the first AI call to
check output quality — for example, verifying that a generated
outline contains at least five sections. If the check fails, route
back to the same AI Agent node with a revised prompt specifying the
deficiency; if it passes, continue to the writing stage. This
self‑correcting loop improves output consistency for production
content pipelines. The chained-request pattern executes sequential
AI model calls with intermediate processing, reducing API costs by
30–50% compared to monolithic single-prompt approaches by enabling
selective model invocation — smaller, cheaper models handle
classification and extraction stages while the full model is
reserved for generation. For the complete three‑stage pipeline
with evaluation, see the
n8n OpenAI Prompt Chain Tutorial.

How do you add retry logic and handle rate limits for production OpenAI workflows in n8n?

OpenAI returns HTTP 429 Too Many Requests when you
exceed rate limits. Production workflows must handle this gracefully
with two complementary strategies. Built‑in retry: in
the OpenAI Chat Model node’s Settings panel, enable Retry On Fail,
set Max Retries to 3, and Wait Between Retries to
1 second. n8n retries with linear backoff for
transient errors. Deliberate throttling: place a
SplitInBatches node before the OpenAI node to process 5–10 items
per batch, with a Wait node (1–5 seconds) between batches.
[5]
[10]

For high‑volume pipelines processing 500+ items, combine batching with
an Error Trigger workflow: when a 429 or 5xx error
occurs, the error workflow catches the failure, waits with exponential
backoff (1 s, 2 s, 4 s, up to 60 s), then re‑enqueues the item via
the Execute Workflow node. Track costs by logging token usage from
the OpenAI node’s output metadata — the response includes
completion_tokens, prompt_tokens, and
total_tokens — multiply by your model’s per‑token price
for exact cost per execution. Set a daily budget alert using a
Schedule Trigger that sums logs and notifies Slack if the total
exceeds a threshold. For the complete error handling architecture
with exponential‑backoff retry loops, see the
n8n Error Handling Nodes guide.

How do you generate and store DALL‑E images from text prompts using the OpenAI Image node?

The OpenAI node supports image generation via the DALL‑E family of
models. Configure the Resource → Image → Generate Image
operation, then select the model (dall‑e‑3 recommended
for production), enter a text prompt (up to 4,000 characters for
dall‑e‑3, 1,000 for dall‑e‑2), and configure output parameters:
Quality (Standard or HD for dall‑e‑3), Resolution
(1024×1024, 1792×1024, or 1024×1792 for dall‑e‑3; 1024×1024 only for
dall‑e‑2), and Style (Natural or Vivid for dall‑e‑3).
[11]
[12]

For multi‑modal pipelines, combine GPT‑4o with DALL‑E 3 through the
AI Agent’s tool connector: attach an HTTP Request Tool sub-node
that calls the OpenAI Images API (https://api.openai.com/v1/images/generations),
describe the tool as “Generate an image from a text prompt using
DALL‑E 3”, and the AI Agent decides when to invoke it based on user
requests. The community n8n-nodes-openai-image-generator
node provides a dedicated interface for DALL‑E with parameters for
size, quality, and style, plus support for image variations.
Store generated images in Google Drive, Azure Blob Storage, or AWS
S3 using the respective n8n nodes. For the complete agent‑driven
image generation pipeline with Telegram delivery, see the
n8n OpenAI Prompt Chain Tutorial.