OpenAI Zero Data Retention Frontier Models API Guide (2026): Privacy, Pricing, and Safe Routing

On August 19, 2026, OpenAI announced expanded Zero Data Retention support for frontier-model API customers and previewed Private Safety Processing. The short version: eligible customers can run sensitive workloads without OpenAI retaining prompts or model responses after processing, while automated safety systems can still look for risky patterns across related interactions without giving OpenAI personnel access to the underlying content.

That matters because the next wave of API apps isn’t just “send a prompt, get a paragraph.” It’s legal review, customer support automation, medical admin, code agents, finance workflows, and internal search over private documents. If you’re building one of those systems, privacy architecture is no longer a footnote. It’s part of the product.

What Zero Data Retention Means in Practice

Zero Data Retention, usually shortened to ZDR, is a contractual and technical promise: customer content is not stored after the request finishes. OpenAI’s post says customer content is not available to OpenAI personnel for review, and enterprise customer data is not used for training unless the customer explicitly opts in.

Don’t confuse that with “no responsibility.” Your app still needs request logs, abuse controls, user permissions, and incident response. The difference is where content lives. In a good ZDR design, the model provider processes the request, but your system owns the durable record. That shifts a lot of responsibility back to you, which is both the point and the tradeoff.

OpenAI’s new Private Safety Processing preview tries to solve the awkward gap between privacy and safety. Some harms only show up across multiple turns. A single message may look harmless; a sequence may show probing, escalation, or an agent drifting away from the user’s instruction. OpenAI says the preview can produce limited safety signals without exposing the underlying content to personnel.

Confirmed GPT-5.6 API Pricing

The ZDR announcement did not change published token prices. Here are the current standard short-context prices for the models most teams will consider when designing a private API workflow.

Long-context requests above 272,000 input tokens are priced higher in OpenAI’s docs: 2x input and 1.5x output for the full request. That detail bites teams that dump entire knowledge bases into every call. Use the token counter before you ship a “just send everything” prototype.

Model Choice for Private API Workloads

My take: don’t make Sol your default just because it’s the flagship. Use Luna for cheap pre-processing, Terra for most agent steps, and Sol only when the task has real complexity or risk. That routing pattern is boring, and that’s why it works.

A Practical ZDR Request Pattern

Even when your provider offers ZDR, you should behave as if every internal log line might be discovered later. The safest pattern is: redact first, send only what the model needs, log metadata without content, and store the human-readable audit trail in your own controlled system.

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-terra",
    "reasoning": {"effort": "medium"},
    "input": [
      {
        "role": "system",
        "content": "You review support tickets. Do not reveal private data. Return JSON only."
      },
      {
        "role": "user",
        "content": "Ticket ID: t_9f21. Redacted issue: customer reports duplicate invoice charge."
      }
    ]
  }'

Notice the boring parts: no raw email, no full card number, no pasted CRM dump, and no permanent prompt log. The ticket ID lets your app join back to the original record inside your environment.

Python: Redact, Route, and Audit Without Storing Content

import os, re, time
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

EMAIL_RE = re.compile(r"[\w.+-]+@[\w-]+\.[\w.-]+")
CARD_RE = re.compile(r"\b(?:\d[ -]*?){13,19}\b")

def redact(text: str) -> str:
    text = EMAIL_RE.sub("[redacted-email]", text)
    text = CARD_RE.sub("[redacted-card]", text)
    return text

def choose_model(risk: str) -> str:
    if risk == "high":
        return "gpt-5.6-sol"
    if risk == "medium":
        return "gpt-5.6-terra"
    return "gpt-5.6-luna"

def classify_ticket(ticket_id: str, body: str, risk: str = "medium"):
    model = choose_model(risk)
    safe_body = redact(body)

    response = client.responses.create(
        model=model,
        input=f"Classify this redacted support ticket as JSON. Ticket ID: {ticket_id}\n\n{safe_body}",
    )

    audit_event = {
        "ticket_id": ticket_id,
        "model": model,
        "risk": risk,
        "timestamp": int(time.time()),
        "content_logged": False,
    }
    print(audit_event)
    return response.output_text

This is the shape you want. The app can answer, debug, and audit without copying private content into random logs. If you need provider flexibility, an OpenAI-compatible router such as KissAPI can sit behind the same interface for non-ZDR workloads or fallback paths, while strict ZDR jobs stay on the approved route.

Node.js: Add a Privacy Gate Before the API Call

import OpenAI from "openai";

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

function privacyGate(payload) {
  if (payload.includes("BEGIN PRIVATE KEY")) {
    throw new Error("Blocked secret material before model request");
  }
  return payload.replace(/[\w.+-]+@[\w-]+\.[\w.-]+/g, "[redacted-email]");
}

export async function summarizeCase(caseId, rawNotes) {
  const safeNotes = privacyGate(rawNotes);

  const result = await client.responses.create({
    model: "gpt-5.6-terra",
    input: `Summarize this case for an internal support lead. Case ID: ${caseId}\n\n${safeNotes}`
  });

  return result.output_text;
}

Blocking secrets before the model call is not paranoia. It’s table stakes. ZDR protects provider-side retention; it doesn’t magically make bad inputs good.

Implementation Checklist

• Separate content from telemetry. Log model, latency, token count, user ID, and request ID. Do not log full prompts by default.
• Redact before routing. Remove emails, keys, card-like numbers, and irrelevant personal data before the API request.
• Use risk-based model selection. Luna for routing, Terra for normal agent work, Sol for the hardest reviews.
• Track long-context cost. Crossing 272,000 input tokens changes the economics fast.
• Keep fallbacks explicit. Don’t silently move sensitive workloads to a non-approved route during incidents.

FAQ

What did OpenAI announce about Zero Data Retention on August 19, 2026?

OpenAI said eligible API customers can use Zero Data Retention with frontier models, meaning prompts and model responses are not retained after processing. OpenAI also previewed Private Safety Processing for detecting risky patterns without personnel seeing customer content.

Does Zero Data Retention lower API costs?

No. ZDR is a privacy and compliance feature, not a discount. Cost control still comes from model routing, prompt design, cached input where available, batch processing, and avoiding unnecessary long-context calls.

Which GPT-5.6 model should I use for private enterprise workloads?

Use GPT-5.6 Luna for cheap classification and extraction, GPT-5.6 Terra for most production agent steps, and GPT-5.6 Sol for high-stakes or complex reasoning. The right default for many teams is Terra, not Sol.