How to Export Claude Instructions for Enterprise Audits

The short answer: the Compliance API is the route for Claude Enterprise admins who need org-wide data out of Claude, and that's where I'd look for member-level 'Instructions for Claude' (claude.ai) and 'Global instructions' (Cowork). The source material I checked, the Claude Platform release notes, confirms the Compliance API exists and names one endpoint. It doesn't document an instructions-export endpoint, its fields, or its beta status.

So this post won't invent an endpoint path for you. It covers what's confirmed, how to find the exact call in the Compliance API guide, and how to store and audit whatever comes back. The audit script near the end runs as-is on made-up sample data in a format I define myself.

What the docs confirm about the Compliance API#

Three facts come straight from the Claude Platform release notes:

• The Compliance API is a real, documented Claude Enterprise surface. The September 1, 2026 entry groups it with the Claude Enterprise endpoints of the Admin API (user management and spend limits) and the Claude Enterprise Analytics API.
• The anthropic-version header is expected. The guides for those endpoints now show it, and the notes say to send it on every request to them, as with the rest of the Claude API.
• The Activity Feed is GET /v1/compliance/activities. The June 9, 2026 entry says it's available on Claude Platform on AWS, authorized there by the ListComplianceActivities IAM action.

That's the full extent of it. The notes don't say whether the instructions export is in beta, what it's called, how it paginates, or what the JSON looks like. Treat anything you read elsewhere about those details as unverified until you see it in the Compliance API guide.

Where 'Instructions for Claude' and 'Global instructions' live#

There are two member-level text fields people mean when they ask about exporting instructions:

Both are free text that each member writes. That matters for auditing. It's user-authored content, so it can contain names, project details, or pasted snippets nobody planned for. Decide up front who's allowed to read the export, because a full export is a copy of every member's personal prompt.

For updates on what changed in claude.ai and Cowork themselves, the release notes point to a separate page: the release notes for Claude Apps. The Platform notes above don't list those app changes.

Finding the exact export call#

I'd work in this order:

1. Open the Compliance API guide under docs.claude.com and look for the instructions or user-settings section. Note the HTTP method, the path, and whether it's marked beta.
2. Check whether a beta header is required. Other beta features in the release notes each use a dated beta header, so a beta endpoint plausibly needs one. The guide is the authority.
3. Check what credential the endpoint wants. The release notes don't cover that, so take it from the guide.
4. Check pagination and rate behavior before you script a loop over every member.

A request skeleton looks like this. Everything in angle brackets comes from the guide, not from me:

curl "<base URL>/<path from the Compliance API guide>" \
  -H "anthropic-version: <value from the API versions page>" \
  -H "<auth header named in the guide>: $COMPLIANCE_KEY" \
  -o raw-export.json

Only the anthropic-version header is confirmed by the notes. Keep the key in an environment variable or a secrets manager, never in the script.

Storing the export#

Once you have raw JSON, don't just overwrite last week's file. A few habits that make later audits easy:

• Keep the raw response untouched. Save it exactly as received, with a timestamp in the filename. If the API shape shifts later, you can still reparse old files.
• Write a normalized copy. Reduce each record to the few fields you care about: a member identifier, which surface it came from, and the text. This is your own format, so you control it.
• Hash each instruction. A SHA-256 per record lets you detect changes without diffing long text, and lets you share a change report without including the text itself.
• Restrict access. Put exports in a bucket or directory limited to the compliance or security group. Set a retention period that matches your policy.
• Append, don't replace. One dated file per run gives you a history you can query.

Auditing changes between exports#

The useful questions are usually: who changed their instructions since last time, who's new, and who removed theirs. The script below compares two snapshots in my own normalized format (member, surface, text). It uses invented sample data, so it's a pattern to adapt, not a parser for the real response.

const crypto = require('crypto');

// Normalized records: this shape is my own, not the API's.
const lastWeek = [
  { member: 'user-001', surface: 'claude.ai', text: 'Answer concisely.' },
  { member: 'user-002', surface: 'cowork', text: 'Use metric units.' },
  { member: 'user-003', surface: 'claude.ai', text: 'Prefer TypeScript examples.' },
];
const thisWeek = [
  { member: 'user-001', surface: 'claude.ai', text: 'Answer concisely.' },
  { member: 'user-002', surface: 'cowork', text: 'Use metric units. Cite sources.' },
  { member: 'user-004', surface: 'claude.ai', text: 'Write in plain English.' },
];

const hash = (t) => crypto.createHash('sha256').update(t).digest('hex').slice(0, 12);
const index = (rows) =>
  new Map(rows.map((r) => [`${r.member}|${r.surface}`, hash(r.text)]));

const before = index(lastWeek);
const after = index(thisWeek);

const report = { added: [], removed: [], changed: [] };
for (const [key, h] of after) {
  if (!before.has(key)) report.added.push(key);
  else if (before.get(key) !== h) report.changed.push(key);
}
for (const key of before.keys()) {
  if (!after.has(key)) report.removed.push(key);
}

console.log(JSON.stringify(report, null, 2));

Notice the report holds keys only, never the instruction text. That's deliberate. You can circulate a change report widely and keep the raw text locked down.

A second small check is useful if your policy forbids certain content in shared instructions, such as credentials. Run a pattern scan over the normalized text and report only the member key and the rule that matched:

const rules = [
  { name: 'looks-like-api-key', re: /\b(sk|key)-[A-Za-z0-9]{16,}\b/ },
  { name: 'looks-like-email', re: /[\w.+-]+@[\w-]+\.[\w.]+/ },
];

const rows = [
  { member: 'user-010', surface: 'cowork', text: 'Reply to me at [email protected]' },
  { member: 'user-011', surface: 'claude.ai', text: 'Be brief.' },
];

for (const r of rows) {
  for (const rule of rules) {
    if (rule.re.test(r.text)) {
      console.log(`${r.member} (${r.surface}): ${rule.name}`);
    }
  }
}

Those patterns are examples. Tune them to what your policy actually cares about, and expect false positives.

Gotchas#

• Assuming the endpoint exists as described. If a blog post, including this one, gives you a path the Compliance API guide doesn't show, trust the guide. Beta endpoints can change.
• Forgetting anthropic-version. The release notes say to send it on every request to the Claude Enterprise endpoints. A missing header is the first thing I'd check if a call fails oddly.
• Mixing up the Activity Feed with an instructions export. GET /v1/compliance/activities is the Activity Feed. The notes don't say it returns instruction text.
• Mixing up platforms. The Activity Feed note applies to Claude Platform on AWS and its IAM action. Your Enterprise setup may authorize differently, so read the guide for your deployment.
• Storing plain text widely. Member instructions are personal content. A shared drive with open permissions turns an audit tool into a leak.
• Treating one snapshot as an audit. A single export shows the present. Changes only show up when you compare dated snapshots.
• Parsing by guesswork. Don't write a parser from a sample you saw once. Read the response schema in the guide and fail loudly on unexpected fields.

Quick reference checklist#

• Read the Compliance API guide for the instructions export: method, path, beta header, auth, pagination.
• Send anthropic-version on every request.
• Save the raw response untouched, with a timestamp.
• Normalize to your own small format: member, surface, text.
• Hash the text; report on hashes and member keys, not content.
• Compare each run against the previous one for added, removed, and changed entries.
• Limit access to exports and set a retention period.
• Re-check the guide and the release notes now and then, since the API and its beta features change.

Quick answers