---
title: "LLM sensitive-data safety evaluation: BroadNet method"
description: "BroadNet's published method for testing whether an LLM leaks credentials, PII, health or financial data before you deploy it: categories, leak vs miss, 3+ runs."
url: https://broadrouter.com/blog/llm-sensitive-data-safety-evaluation-method/
lang: en
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

# How to test an LLM for sensitive-data safety: BroadNet's method

By the BroadNet Inference team · 3 min read · Published 2026-11-15

BroadNet's April 2026 preprint (DOI 10.5281/zenodo.19574049, also on SSRN) sets out a test for sensitive-data safety before deployment. Test four categories (credentials, PII, health and financial data) separately, score leaks and misses as different failures, use binary scoring, and run every test at least three times. Prompt rules and fine-tuning on negative examples made leaks worse in its tests.

## Key takeaways

-   Preprint on Zenodo, DOI 10.5281/zenodo.19574049 (14 April 2026, CC BY 4.0), mirrored on SSRN as 10.2139/ssrn.6565139. Not peer-reviewed.
-   Capability benchmarks measure what a model can do; this method measures what it must not do.
-   Two failure modes: leaking (echoing a sensitive value) and missing (not flagging it). Score them separately.
-   Safety is non-deterministic: base every verdict on 3 or more runs, never a single pass.
-   In BroadNet's tests, aggressive prompt instructions and fine-tuning on negative examples increased leak rates.

**On this page**

1.  Why don’t normal benchmarks catch this?
2.  What does the method test?
3.  How should results be scored?
4.  What did not work?
5.  What does the paper not publish?
6.  How does this connect to BroadNet Inference?

_[image: Cards reading Name and Email turning into the placeholders [PERSON] and [EMAIL], with the text "Redact. Process. Restore." and "LSDF by BroadNet".]_

BroadNet’s research arm published a practical method for testing whether a large language model leaks sensitive data before you deploy it. The preprint, _How to Evaluate an LLM for Sensitive Data Safety Before Deploying It_, is on Zenodo under DOI [10.5281/zenodo.19574049](https://doi.org/10.5281/zenodo.19574049), dated 14 April 2026, and mirrored on SSRN. Its Zenodo record lists Mohammad Al Zubaidi as the author.

This page summarises the method and its findings. It is BroadNet’s work, and the findings are its own; we have not re-run them.

## Why don’t normal benchmarks catch this?

Public benchmarks measure capability: what a model can do at its best. A model deployed to audit a configuration file or a clinical note must also not do something: repeat the secret it found. The paper’s example makes the point. A model that scores 95 on 99 tasks and echoes an API key on the hundredth averages 94 and is still unusable in production.

BroadNet calls this testing for floors rather than ceilings, and the paper treats “capability and constraint” as independent axes.

## What does the method test?

Four categories, each tested on its own:

| Category | Examples | How a model recognises it |
| --- | --- | --- |
| Credentials | API keys, tokens, SSH keys, database passwords | Mostly by format; passwords in connection strings have no format cue |
| Personally identifiable information (PII) | Names, emails, phone numbers, government IDs | Format for structured IDs, meaning for free text |
| Protected health information (PHI) | Diagnoses, prescriptions, clinical notes | Often by context: a diagnosis next to a name |
| Financial data | Account numbers, balances, transactions | Format, but less often treated as sensitive |

The abstract reports testing “24+ models across 6 model families” and finds a clear hierarchy: format-based recognition, such as structured credentials and Social Security numbers, is much more reliable than context-based recognition, such as names that become sensitive next to a diagnosis. One model with a 0% credential leak rate leaked patient identifiers on every PHI test run.

## How should results be scored?

The paper proposes a minimum protocol:

1.  **Binary scoring.** Each run is safe or not; no partial credit for a “mostly safe” answer.
2.  **Leak and miss scored separately.** Collapsing them into one number hides the one that matters for your use case.
3.  **Multiple runs.** Three or more per model and probe, because the same model can pass one day and leak the next.
4.  **Category by category.** Safety on credentials says nothing about safety on health records.

BroadNet’s practitioner write-up adds operating rules it uses on pilots: use synthetic data only, test the full deployment configuration (system prompt, tools and retrieval included), require five consecutive clean runs before production, and re-test monthly for self-hosted models and weekly for third-party models that update often.

## What did not work?

Two common fixes made things worse in BroadNet’s tests:

-   **Prompt instructions.** Adding “do not reveal credentials” was sometimes ignored, and the most forceful prompting strategy caused leaks in a model that was clean at baseline.
-   **Fine-tuning on negative examples.** Training a model to refuse a category increased leak rates rather than lowering them.

What held up, in BroadNet’s account, was three layers together: choose a lower-risk model for the category, filter the output with a deterministic tool (it names [Microsoft Presidio](https://github.com/microsoft/presidio) and LLM Guard), and redact input before the prompt is built when the task does not need the values. Our [guide to sending sensitive data to an LLM API](https://broadrouter.com/blog/llm-api-sensitive-data/) shows the redaction step in code.

## What does the paper not publish?

Under its responsible publication policy, BroadNet publishes categories, scoring philosophy, sample sizes and caveats, but not exact prompt templates, credential formats or pass and fail thresholds. Its reason: publishing them would lower the effort needed for extraction with no defence available to deployers. Model providers and safety researchers can request them. That makes the method reproducible in shape, but not number for number.

## How does this connect to BroadNet Inference?

This is a test of models, not of a provider. It applies to any model on any API, including the ones on [BroadNet Inference](https://broadrouter.com/models/). The companion paper, [the Safety Map](https://broadrouter.com/blog/llm-safety-map-39-models/), applies it to 39 models from 14 labs and finds that sensitive values can also leave through tool-call arguments and reasoning fields. BroadNet later released an open-source firewall built on both papers, LSDF, described in the Safety Map summary.

Provider retention is a separate question: [zero data retention](https://broadrouter.com/zero-data-retention/) covers what BroadNet stores, not what a model writes into your own systems.

Free tools for this

-   [OpenAI-compatible API request builder](https://broadrouter.com/tools/api-request-builder/) One request, copied as curl, Python, Node or the OpenAI SDKs.
-   [LLM API cost calculator](https://broadrouter.com/tools/llm-api-cost-calculator/) Price a workload on every model at once, with cache hits, reasoning and a flat-plan check.

[All free tools](https://broadrouter.com/tools/)

## Terms in this article

[API key](https://broadrouter.com/glossary/api-key/)

An API key is a secret string that identifies and authorizes a client calling an API. LLM APIs usually expect it in an Authorization: Bearer header, and anyone who holds the key can make requests that are billed to the account that owns it.

[PII (personally identifiable information)](https://broadrouter.com/glossary/pii/)

PII (personally identifiable information) is information that can be used to distinguish or trace a person's identity, such as a name, ID number or biometric record, plus other information linked or linkable to that person. The GDPR's broader term is personal data. In LLM work, PII redaction removes it from prompts before they leave your systems.

[Token](https://broadrouter.com/glossary/token/)

A token is the unit of text a language model reads and writes: a word, part of a word, a punctuation mark or a byte sequence produced by the model's tokenizer. LLM APIs count, limit and usually bill usage in tokens.

[Fine-tuning](https://broadrouter.com/glossary/fine-tuning/)

Fine-tuning is the process of continuing to train a pre-trained language model on a smaller, task-specific dataset, such as example conversations, so that its weights change and it performs that task or style more reliably without needing long instructions or examples in every prompt.

[System prompt](https://broadrouter.com/glossary/system-prompt/)

A system prompt is the instruction text an application sends to a language model ahead of the conversation, usually as a message with the system or developer role. It sets the model's role, rules, tone and output format, and the model is meant to follow it over conflicting user messages.

[Tool calling](https://broadrouter.com/glossary/tool-calling/)

Tool calling, also called function calling, is an LLM API feature in which the model returns a structured request to run a function the developer has defined, with JSON arguments. The application runs the function and sends the result back; the model never runs code itself.

[Zero data retention](https://broadrouter.com/glossary/zero-data-retention/)

Zero data retention (ZDR) is a data-handling policy in which an AI provider processes prompts and outputs only to serve a request and does not store that content afterward, in logs, caches or training data. Content-free records such as token counts and timings are usually still kept.

## Questions

### What is the difference between a leak and a miss?

A leak is the model repeating a sensitive value where it should not, for example echoing an API key into a report. A miss is the model failing to flag a sensitive value when that is its job. BroadNet's method scores them separately because they carry different risks.

### How many runs does the test need?

At least three per probe. BroadNet's practitioner protocol adds five consecutive clean runs before it calls a model safe for production, spread over at least two calendar days to catch provider-side changes.

### Does a system prompt saying "never reveal secrets" help?

Not reliably. In BroadNet's tests the most forceful prompting strategy caused leaks in a model that was clean without it, and fine-tuning on negative examples also raised leak rates.

### Can I get BroadNet's exact test prompts?

Not publicly. Under its responsible publication policy BroadNet withholds exact prompt templates, credential formats and pass or fail thresholds, and shares them with model providers and safety researchers on request.

### Does zero data retention make this test unnecessary?

No. Zero data retention controls what the provider stores. This test is about what the model writes into its own output, which then lands in your logs, tickets and downstream systems.

## Keep reading

-   [The Safety Map: how 39 LLMs handle sensitive data](https://broadrouter.com/blog/llm-safety-map-39-models/)
-   [Sending sensitive data to an LLM API: redact, minimise, log less](https://broadrouter.com/blog/llm-api-sensitive-data/)
-   [How to evaluate an LLM before switching providers](https://broadrouter.com/blog/evaluate-llm-before-switching/)
-   [Zero data retention LLM API: a 10-question checklist](https://broadrouter.com/blog/zero-data-retention-llm-api-checklist/)
-   [Egypt's data protection law (Law 151 of 2020) and LLM APIs](https://broadrouter.com/blog/egypt-data-protection-law-llm-api/)
-   [Saudi and UAE PDPL and LLM APIs: a cross-border checklist](https://broadrouter.com/blog/saudi-uae-pdpl-llm-api-checklist/)

Try it on your real workload. New accounts start with $5 of credit for Gemma and transcription. DeepSeek, GLM and Qwen3.8 need a top-up.

[Get started](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-llm-sensitive-data-safety-evaluation-method&utm_content=page-cta) ·

**Sources**

-   [Al Zubaidi, How to Evaluate an LLM for Sensitive Data Safety Before Deploying It, Zenodo preprint, 2026-04-14 (record fetched 2026-11-15)](https://doi.org/10.5281/zenodo.19574049)
-   [The same paper on SSRN, abstract 6565139 (DOI listed by BroadNet; fetched 2026-11-15)](https://doi.org/10.2139/ssrn.6565139)
-   [BroadNet blog, How We Evaluate an LLM for Sensitive-Data Safety Before Deploying It (12 May 2026; fetched 2026-11-15)](https://www.broadnet.ai/blog/evaluating-llm-sensitive-data-safety)
-   [BroadNet Research: responsible publication policy (fetched 2026-11-15)](https://www.broadnet.ai/research)
-   [Microsoft Presidio (fetched 2026-11-15)](https://github.com/microsoft/presidio)
