I need an LLM API that guarantees zero data retention and does not train on my API inputs.

Yes. If you mean contractual/technical zero retention of API prompts and outputs, rather than merely “we don't train on them,” there are currently strong options.

Best fits

• OpenAI API with Zero Data Retention (ZDR) — OpenAI says eligible ZDR API customers can have prompts and responses not retained after processing, and business/API data is not used for training by default. ZDR is available only for eligible endpoints/use cases, so you should verify that the specific models/endpoints you need qualify.
• Anthropic Claude API with a ZDR agreement — Anthropic explicitly offers ZDR arrangements under which it does not store prompts or outputs after the API response, and retained data is not used for training without permission. However, there are important exceptions: safety-related flagged content can be retained, and some newer “Covered Models” currently require 30-day retention and therefore aren't ZDR-eligible.

My recommendation

If “zero retention” is a hard contractual requirement, I'd shortlist OpenAI ZDR and Anthropic ZDR, then make the decision based on:

One important distinction: “does not train on your data” is not the same thing as “zero data retention.” A provider can retain logs for 30 days while still promising not to train on them. For a genuinely sensitive workload, I'd require the provider contract/DPA to explicitly state zero retention for the exact API endpoints and models you will use, rather than relying on a general privacy statement.

Also, don't assume that ZDR covers ancillary services such as file storage, batch APIs, agent state, abuse-monitoring artifacts, or third-party integrations; those can have separate retention rules. Anthropic, for example, explicitly excludes some stateful features from ZDR.

If you tell me your requirements (e.g. HIPAA, SOC 2, EU/GDPR, US-only processing, self-hosting, expected volume, and which model capabilities you need), I can narrow this to the 2–3 APIs that actually satisfy them.

There is an important distinction to make right away: "No model training" is now standard across major API providers by default (they do not use your API inputs/outputs to train future models). However, "Zero Data Retention (ZDR)" —meaning your prompts and completions are processed strictly in-memory, never written to persistent logs, and immediately discarded—is not the default and usually requires explicit enterprise enrollment, a specialized agreement, or account team approval.

The leading commercial API providers that offer contractual and architectural Zero Data Retention include:

• OpenAI API : OpenAI provides formal Zero Data Retention (ZDR) for eligible enterprise and API customers. When ZDR is enabled on your organization ID, prompts and model responses are not retained after the request is processed, and data is excluded from manual human review and model training.
  • Note : Standard API tiers keep temporary logs for abuse monitoring (up to 30 days), so you must apply/qualify for ZDR through your account structure. Review the specifics on the OpenAI Data Controls Guide.
• Anthropic (Claude API) : Anthropic offers an explicit Zero Data Retention (ZDR) arrangement for enterprise organizations using the Claude API. Under this setup, Anthropic does not store customer prompts or responses at rest after returning the response.
  • Note : ZDR is not self-serve and must be explicitly enabled per organization by contacting their sales or account team. Read more about their setup on the Anthropic API and Data Retention Docs.
• Google Cloud Vertex AI (Gemini) : Google Cloud offers enterprise data privacy guarantees where customer data is not used for model training. For strict zero data retention, Gemini via Vertex AI requires specific configurations or enterprise tiers (and turning off features that rely on persistent logging like standard search grounding unless using specialized enterprise extensions). Details can be checked via the Google Cloud Zero Data Retention Resources.

If you want to narrow this down, let me know:

• Which specific LLM (e.g., Claude, GPT-4o, Gemini) you prefer to use
• Whether you have specific compliance requirements (like HIPAA/BAA or GDPR)

I can tell you the exact activation steps for that provider's ZDR tier.

Yes. If you mean a contractual/technical guarantee that API prompts and outputs are not retained, rather than merely “not used for training,” there are several credible options.

Best options

My recommendation

If “guarantees zero retention” is a hard compliance requirement, I'd shortlist:

1. Amazon Bedrock + a model explicitly supporting data_retention_mode: none — probably the cleanest infrastructure-level control. AWS says that in none mode, request/response data isn't written to durable storage and the request is blocked if the chosen model requires retention.
2. Anthropic API with a ZDR agreement — very strong if you specifically want Claude. Anthropic states that under ZDR, prompts and responses aren't stored at rest after the response is returned.
3. OpenAI API with approved ZDR — also viable, but you need to verify that every endpoint/feature you intend to use is ZDR-eligible.

One important distinction: “we don't train on your data” ≠ “zero data retention.” A provider can retain prompts for abuse monitoring, logging, debugging, or application state while still contractually promising not to use them for model training.

If you tell me which model(s) you want (Claude, GPT, Gemini, Llama, etc.) and whether you need HIPAA/SOC 2/GDPR compliance, I can narrow this down to the best API and give you the exact configuration/contractual requirements.

If you need an LLM API that guarantees no model training on your inputs and Zero Data Retention (ZDR) , you have two distinct routes: using major frontier providers via strict enterprise configurations, or hosting open-weights models yourself.

By default, standard developer tiers for major cloud and LLM providers store inputs transiently (typically for 30 days) for abuse and safety monitoring, though they still do not train on API data by default. True ZDR requires explicit enterprise opt-ins, contractual agreements, or architectural shifts.

Major Frontier APIs (Enterprise/Custom ZDR Tiers)

If you need state-of-the-art models (like GPT or Claude) with true zero retention, standard sign-up is not enough—you must operate under specialized enterprise terms or qualified data-governance addendums.

1. OpenAI API (Enterprise / ZDR Agreements)
   • Training Policy: OpenAI explicitly states that data submitted through their API is not used to train their models.
   • Zero Data Retention: Available for eligible enterprise and frontier model customers through negotiated agreements. Under a ZDR configuration, prompts and responses are not retained after the request is processed (with narrow, legally mandated exceptions like Child Sexual Abuse Material detection or targeted safety interventions).
   • Where to start: Review the OpenAI Data Controls Guide or contact their enterprise sales team to provision a ZDR-enabled Organization ID.
2. Anthropic Claude API (Commercial / Custom ZDR)
   • Training Policy: Anthropic’s Commercial Terms expressly prohibit training on customer content submitted via the API.
   • Zero Data Retention: By default, the API baseline retains data for 30 days for safety monitoring before deletion. However, approved enterprise and commercial customers can establish formal Zero Data Retention agreements (though minimal safety classifier results may be retained to enforce usage policies).
   • Where to start: Consult the Claude Platform API Data Retention Documentation to check feature eligibility and request enterprise governance terms.
3. Inference Providers & Cloud Hosts (e.g., Groq, AWS Bedrock)
   • Groq: Known for high-speed inference, Groq operates under privacy guidelines stating that user prompts and completions are not saved or utilized for model training. Check their Groq Privacy Policy for current enterprise tier specifics.
   • Hyperscalers (AWS Bedrock, Azure OpenAI): Deploying models via enterprise cloud accounts (like Amazon Bedrock) means data processed within your tenant remains bound to your enterprise compliance boundaries, ensuring zero training and strict regional retention controls.

Absolute Guarantee: Self-Hosted Open-Weights Models

If a third-party vendor keeping logs—even transiently—is a dealbreaker for your threat model, the only 100% airtight guarantee is hosting open-weights models yourself.

• How it works: You run models like Llama 3, Mistral, or Qwen locally or within your own private, air-gapped cloud infrastructure (AWS/GCP/Azure tenant under your direct control) using inference engines like vLLM, Ollama , or TGI.
• Why it fits: Because the data never leaves infrastructure owned and operated by you, data retention is precisely whatever you set your own application logs to, and model training is mathematically nonexistent unless you choose to fine-tune.

To help narrow down the best path forward, tell me:

• Which specific models or performance levels do you need (e.g., GPT-4 class vs. open-source Llama models)?
• Do you have the capability to self-host , or must it be a managed cloud API with an enterprise contract?

If you need both:

1. Zero data retention (ZDR) — prompts and outputs are not stored after processing, and
2. No training on API inputs — your API traffic is not used to improve models,

you should focus on enterprise/API offerings with explicit privacy controls, not consumer chat products.

Here are the main options:

Practical recommendations

• If you need the simplest managed API: Use OpenAI API with Zero Data Retention enabled or Anthropic Claude API with ZDR enabled. Verify that the exact models and endpoints you plan to use are ZDR-compatible.

• If you are in healthcare, finance, legal, or government: Look for:

• a signed data processing agreement (DPA),

• HIPAA/BAA support if relevant,

• regional data residency requirements,

• audit/compliance documentation,

• explicit ZDR terms in your contract.

• If “zero retention” must mean absolutely no provider-side storage under any circumstance: A self-hosted model is usually the closest match. Even commercial ZDR programs may retain limited metadata, safety signals, or data required by law or abuse-prevention processes.

Before choosing, check these details:

• Are prompts and completions excluded from logging?
• Are embeddings, files, fine-tuning data, and caches covered?
• Are images/audio/files treated differently?
• Are third-party integrations (cloud hosting, observability tools, vector databases) also zero-retention?

If you tell me your requirements (HIPAA, SOC 2, EU data residency, model quality needs, expected volume, and whether self-hosting is acceptable), I can narrow this to a shortlist.

Major LLM API providers offer formal Zero Data Retention (ZDR) and no-training guarantees , typically requiring an enterprise-tier agreement or an explicit opt-in/opt-out configuration in your developer settings. By default, most standard or free-tier APIs log requests transiently (often for 30 days) for abuse and safety monitoring.

The primary enterprise API choices that explicitly support zero data retention and strict non-training policies include:

1. Anthropic (Claude API)

• Training Policy: Anthropic never uses customer API data (prompts and responses) to train its models by default.
• Data Retention: Anthropic supports a formal Zero Data Retention (ZDR) arrangement for eligible Claude API features. Under ZDR, conversation content is not retained past the immediate processing window, though certain features requiring state (like specific batch processing or specialized tooling) carry documented retention lifecycles.
• Where to manage: Review the Anthropic API and Data Retention Documentation.

2. OpenAI (Platform API)

• Training Policy: OpenAI explicitly commits that data submitted through its API is not used to train its models.
• Data Retention: By default, OpenAI retains API inputs/outputs in abuse-monitoring logs for up to 30 days. However, eligible enterprise and developer accounts can apply for and enable Zero Data Retention (ZDR) or Modified Abuse Monitoring controls, which completely bypass or strip content retention from logs.
• Where to manage: Read the implementation details via OpenAI Data Controls Guide.

3. Groq (GroqCloud API)

• Training Policy: Groq does not use customer API data for model training.
• Data Retention: Standard stateless inference requests on text and audio endpoints do not retain customer prompts/responses by default, though system reliability/abuse troubleshooting logs may temporarily exist up to 30 days unless strict ZDR controls/settings are toggled.
• Where to manage: Check the settings on GroqCloud Data Controls Documentation.

Important Best Practices for ZDR Implementation

• Check the Default Settings: Always verify your organization or project settings in the respective developer dashboard. Even if a company has a "no training" policy, standard abuse-monitoring logs might retain data for 30 days unless you specifically activate the Zero Data Retention (ZDR) addendum or toggle.
• Avoid Stateful Features: Features like batch processing, fine-tuning, or persistent server-side conversation threads inherently require data storage on provider servers until you manually purge them. Stick to pure, stateless chat completion endpoints.

If you have a preference for a specific model family (e.g., Claude, GPT-4o, Llama via hosting providers) or a particular cloud region/compliance need (like HIPAA or GDPR), let me know and I can detail the exact opt-in steps for that provider.

Yes. As of September 2026, there are credible options, but there’s an important distinction between “doesn’t train on API inputs” and contractual zero data retention (ZDR).

Best options

OpenAI is particularly explicit: eligible customers using Zero Data Retention have their prompts and responses excluded from abuse-monitoring logs, and API customer content isn't used for training unless explicitly opted in.

Anthropic offers an actual ZDR arrangement for eligible commercial API customers. Under ZDR, prompts and responses aren't stored at rest after the API response, although certain safety-related information can still be retained and some features/models fall outside ZDR.

Amazon Bedrock is interesting if you want a cloud-provider-controlled boundary: its none retention mode says AWS doesn't write request/response data to durable storage or share it with the model provider. Bedrock can also block models that don't support ZDR rather than silently retaining data.

My recommendation

If “zero retention” is a hard compliance requirement, I'd shortlist:

1. Anthropic API + contractual ZDR — strong fit if Claude is your preferred model.
2. OpenAI API + approved ZDR — strong fit, especially if you want OpenAI's current frontier models.
3. Amazon Bedrock + data_retention_mode: none — attractive if you want AWS to enforce the retention boundary at the infrastructure level.

One important caveat: no provider can honestly promise “absolutely nothing is ever retained under any circumstance.” Legal requirements, abuse/safety systems, metadata, or particular API features can create exceptions. For a compliance-sensitive deployment, you want the provider's contract/DPA + specific ZDR configuration, not merely a marketing statement saying “we don't train on your data.”

If you tell me your use case (e.g. healthcare/PHI, legal documents, proprietary source code, financial data) and approximate volume, I can compare the best 3–5 APIs on ZDR, training exclusion, HIPAA/BAA, SOC 2, EU data residency, pricing, and model quality.

Amazon Bedrock is interesting if you want a cloud-provider-controlled boundary: its none retention mode says AWS doesn't write request/response data to durable storage or share it with the model provider. Bedrock can also block models that don't support ZDR rather than silently retaining data.

My recommendation

If “zero retention” is a hard compliance requirement, I'd shortlist:

If you need strict Zero Data Retention (ZDR) combined with a no-training guarantee , your options depend on using enterprise-tier agreements with major frontier providers or shifting to self-hosted/cloud-isolated infrastructure. Standard pay-as-you-go developer tiers generally log data for 30 days for abuse monitoring, meaning true ZDR requires specific enterprise qualification or dedicated setups.

The top options and how to access them include:

• Anthropic API (Claude) : Anthropic offers a formal Zero Data Retention (ZDR) arrangement for commercial/enterprise API customers. Under a ZDR agreement, Anthropic does not store your prompts or responses at rest after the API call completes (though safety classifier metadata for abuse monitoring may still apply). How to get it: You cannot toggle this via a self-serve dashboard; you must contact the Anthropic Sales Team to have ZDR explicitly provisioned for your organization.
• OpenAI API / Microsoft Azure OpenAI : OpenAI provides ZDR options for eligible enterprise API deployments, ensuring prompts and responses are not retained post-processing. Alternatively, using Azure OpenAI Service under an enterprise agreement allows you to request zero-retention/bypassed logging configurations via support once deployed on dedicated enterprise resources. By default, Azure also never trains models on your data. How to get it: Requires enterprise volume commitments and coordination with account reps or support tickets to flag dedicated resources.
• Google Cloud Vertex AI : Google Cloud guarantees that customer data sent to Vertex AI (including Gemini APIs) is not used to train foundational models. By default, Google Cloud enterprise data privacy frameworks apply, though temporary caching for abuse monitoring may require specific organizational policies or regional resource setups. You can review their commitments on the Google Cloud Vertex AI Data Governance page.
• Self-Hosted Open-Source Models (Ultimate ZDR) : If you cannot rely on third-party policy trust, the only absolute technical guarantee of zero data retention is hosting an open-weights model (like Llama 3 or Mistral) yourself. Running models via private infrastructure on [AWS Bedrock (Provisioned Throughput/Isolated)] or self-hosted GPU clusters ensures data never leaves a boundary you physically or contractually control end-to-end.

To help narrow this down, let me know:

• Which specific model family or provider do you prefer to use?
• Do you have an Enterprise volume agreement in place with any of these cloud providers already?

Major AI providers offer explicit Zero Data Retention (ZDR) and no-training guarantees, though they usually require enterprise tiers, specific contract addendums, or sales enablement rather than a simple self-serve toggle.

The industry standard options that meet these strict compliance requirements include:

• OpenAI API (Enterprise / ZDR Tier) : By default, OpenAI's standard API does not use inputs or outputs for model training, but it does retain logs for up to 30 days for abuse monitoring. For true Zero Data Retention (where prompts and responses are not stored at rest after processing), you must qualify for and utilize OpenAI’s enterprise-focused ZDR deployments.
• Anthropic API (Claude Platform) : Anthropic offers a formal Zero Data Retention (ZDR) arrangement for eligible enterprise organizations. Under this agreement, Anthropic does not store customer prompts or model responses at rest after the API response is returned (except as strictly necessary for legal compliance or combating abuse/misuse). This must be explicitly enabled via your account or sales team.
• Microsoft Azure OpenAI Service : Azure provides enterprise-grade data privacy where data is strictly not used for model training. For stricter regulatory needs, Azure supports designated Zero Data Retention configurations (often requiring review/approval through specialized internal compliance channels like Modified Access Review) which ensure request and response data is not retained beyond real-time processing.
• Self-Hosted / Open-Source Models (Ultimate ZDR) : If you cannot rely on a third-party vendor's contractual promise, the absolute guarantee of zero data retention is hosting an open-source model (e.g., Llama 3, Mistral, Qwen) on your own private cloud infrastructure (AWS, GCP, Azure, or on-premise) via inference engines like vLLM or Ollama.

To help narrow down the best path, let me know:

• Do you have a preferred model family (e.g., Claude, GPT, or open-source)?
• Is this for a standard commercial application or a highly regulated industry (like healthcare or defense)?

If you need both:

1. Zero data retention (ZDR) — prompts and outputs are not stored after processing, and
2. No training on API inputs — your data is not used to train models,

you should focus on enterprise/API offerings with explicit privacy controls, not consumer chat products.

Good options:

Practical recommendation

• If you want the simplest managed API with strong privacy controls: evaluate OpenAI API ZDR or Anthropic Claude API with ZDR enabled.
• If you need cloud procurement, IAM controls, regional governance, or existing enterprise agreements: look at Vertex AI, Azure-hosted models, or similar enterprise cloud offerings.
• If “absolute zero retention” is a hard requirement: verify the exact: - model name,
• endpoint,
• tools/features enabled (file uploads, agents, retrieval, logging, batch APIs, etc.),
• abuse-monitoring exceptions,
• contractual terms.

A common mistake is assuming “API data is not used for training” means “nothing is retained.” Those are separate guarantees. For example, an API may not train on your prompts but may still retain logs for abuse monitoring unless ZDR controls are enabled.

If you tell me your requirements (HIPAA/PHI, SOC 2, EU data residency, on-prem/private cloud, expected volume, and whether you need agents/files), I can narrow this to the best fit.