# Verbatim — AI Vendor Evidence Packets (`jwtor7/verbatim-vendor-evidence`) Actor

Exact public-source quotes on training use, retention, deletion, zero-data retention, processing regions, and subprocessors for 46 AI vendors. Retrieve evidence packets or compare captures. Provided by Junior Williams Consulting Inc.

- **URL**: https://apify.com/jwtor7/verbatim-vendor-evidence.md
- **Developed by:** [Junior Williams](https://apify.com/jwtor7) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 evidence packet delivereds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Verbatim — AI Vendor Evidence Packets (Apify Actor)

**The terms you signed off on are not the terms anymore.**

Verbatim watches what AI vendors publish about your data, and quotes it
back exactly. For each of 46 AI vendors (product + plan), this Actor
returns exact quoted passages — each with its source URL and capture
date — on six dimensions:

1. Training use of customer data
2. Retention
3. Deletion
4. Zero-data-retention
5. Processing regions
6. Subprocessors

Where a vendor's published documents say nothing about a dimension, the
packet says so explicitly (`NOT_SPECIFIED`). Verbatim never paraphrases,
infers, or fills gaps. Packets are evidence, not legal advice, not
certification, and not a guarantee of vendor behaviour.

This Actor is a thin client over the public Verbatim REST API at
https://api.trustcyber.ca (documentation: https://api.trustcyber.ca/docs).

### Modes and pricing

| Mode | Input | Result | Price |
| --- | --- | --- | --- |
| `list_vendors` | none | All 46 vendors (slug, vendor, product, plan), one dataset item each | Free |
| `get_packet` | `vendorSlug`, `format` | The vendor's latest evidence packet | **US$0.10 per run** |
| `compare_packet` | `vendorSlug` | Before/after quote pairs between the two most recent captures | **US$0.05 per run** |
| `get_all_packets` | none | Every vendor's latest evidence packet, one dataset item each (46 items) | **US$2.99 per run** |

Pricing is pay-per-event, set by the pricing research enacted
2026-10-23 (replacing the original US$5 / US$12 guess). The events
(`packet-delivered` at US$0.10, `comparison-delivered` at US$0.05,
`bundle-delivered` at US$2.99) and their prices are declared in
`.actor/actor.json` under `pricingInfos` (`pricingModel: PAY_PER_EVENT`),
and the Actor calls `Actor.charge(...)` once per successful paid run.
Platform usage is included in the event prices, the actor-start event
stays at its platform default, and no Store discount tiers are enabled
at launch, so the headline prices above are the real prices.
`list_vendors` never charges. Failed or unknown-vendor runs are never
charged. A comparison for a vendor with only one capture returns
`compared: false` with an explanation instead of a diff, and is NOT
charged: the `comparison-delivered` event fires only when a comparison
actually ran. The prices take effect only when the Actor's owner
confirms the pricing in the Apify Console (Monetization tab) on their
own account; until then the values in `actor.json` are intent, not
live billing.

### Input

```json
{
  "mode": "get_packet",
  "vendorSlug": "anthropic",
  "format": "json"
}
```

| Field | Type | Default | Notes |
| --- | --- | --- | --- |
| `mode` | string (enum) | `list_vendors` | `list_vendors` | `get_packet` | `compare_packet` | `get_all_packets` |
| `vendorSlug` | string | — | Required for `get_packet` / `compare_packet`. A slug from `list_vendors`, e.g. `anthropic`, `openai`, `microsoft-azure-openai`. |
| `format` | string (enum) | `json` | `get_packet` only: `json` (structured packet) or `markdown` (rendered report) |
| `apiBaseUrl` | string | `https://api.trustcyber.ca` | Advanced: point at your own Verbatim instance |

### Output

Results go to the run's **default dataset**, and the primary payload is
also stored under the **`OUTPUT`** key of the default key-value store.

- `list_vendors`: one dataset item per vendor:
  `{"mode": "list_vendors", "slug": "anthropic", "vendor": "Anthropic", "product": "Claude (Commercial / API)", "plan": "Commercial terms (Team, Enterprise & API)"}`
- `get_packet` (json): one dataset item, the full packet:
  `{"vendor", "product", "plan", "slug", "headline", "captured_at", "disclaimer", "sources": [...], "findings": {"training_use": {"status": "FOUND", "passages": [{"quote", "source_url", "source_key", "captured_at"}]}, ...}}`
- `get_packet` (markdown): one item
  `{"mode": "get_packet", "slug", "format": "markdown", "markdown": "# Verbatim Evidence Packet: ..."}`.
- `compare_packet`: one item with `compared`, `from`, `to`,
  `change_count`, and `changes` (before/after quote pairs); or
  `compared: false` plus an `explanation` when a second capture does
  not exist yet.
- `get_all_packets`: 46 dataset items, one full packet per vendor (same
  shape as `get_packet` JSON); the `OUTPUT` key holds
  `{"mode": "get_all_packets", "count": 46, "packets": [...]}`.

### Examples

List the covered vendors (free):

```json
{ "mode": "list_vendors" }
```

Get Anthropic's current packet as JSON (US$0.10):

```json
{ "mode": "get_packet", "vendorSlug": "anthropic", "format": "json" }
```

Get OpenAI's packet as a Markdown report (US$0.10):

```json
{ "mode": "get_packet", "vendorSlug": "openai", "format": "markdown" }
```

See what Microsoft Azure OpenAI changed between its last two captures (US$0.05):

```json
{ "mode": "compare_packet", "vendorSlug": "microsoft-azure-openai" }
```

Get every vendor's packet in one run (US$2.99 bundle):

```json
{ "mode": "get_all_packets" }
```

### Sample packet (full, real)

One complete packet, exactly as `get_packet` returns it in Markdown form
(Anthropic, captured 2026-10-20; the live version is at
https://api.trustcyber.ca/packet/anthropic.md):

***

## Verbatim Evidence Packet: Anthropic

**The terms you signed off on are not the terms anymore.**

- Product: Claude (Commercial / API)
- Plan scope: Commercial terms (Team, Enterprise & API)
- Captured: 2026-10-20

> Verbatim packets report what vendors publish, quoted and dated. They are evidence, not legal advice, not certification, and not a guarantee of vendor behaviour.

### Findings

#### Training use of customer data

> See our Non-User Privacy Policy for more details on the data used to train our models, and the different stages of development.

Source: https://www.anthropic.com/legal/privacy (captured 2026-10-20)

> Anthropic obtains personal data from third party sources in order to train our models.

Source: https://www.anthropic.com/legal/privacy (captured 2026-10-20)

> Anthropic is a global company, and when you access our Services, your personal data is transferred to our servers in the US, or to other countries outside the European Economic Area (“EEA”) and the UK for the purposes outlined in Section 2 of this Privacy Policy, for example to provide you with the Service, or to train our models, or to conduct research.

Source: https://www.anthropic.com/legal/privacy (captured 2026-10-20)

#### Retention

> Anthropic retains your personal data for as long as reasonably necessary for the purposes and criteria outlined in this Privacy Policy and explained further in our privacy center.

Source: https://www.anthropic.com/legal/privacy (captured 2026-10-20)

#### Deletion

> You also are able to delete individual conversations, which will be removed immediately from your conversation history and automatically deleted from our back-end within 30 days.

Source: https://www.anthropic.com/legal/privacy (captured 2026-10-20)

> H.1.b. delete all copies of Customer Data (including Customer Personal Data) processed by Anthropic or any Subprocessors, except to the extent (i) Applicable Data Protection Laws or other applicable legal or regulatory requirements requires storage of the Customer Data, (ii) retention of the Customer Data by Anthropic is necessary to resolve a dispute between the parties, or (iii) retention of the Customer Data is necessary to combat harmful use of the Services.

Source: https://www.anthropic.com/legal/data-processing-addendum (captured 2026-10-20)

#### Zero-data-retention

NOT SPECIFIED in the sources captured.

#### Processing regions

NOT SPECIFIED in the sources captured.

#### Subprocessors

> By providing us with personal data, you acknowledge and agree that your personal data may be transferred or disclosed to other jurisdictions for processing and storage outside of Canada, including to the United States and the countries listed on our Subprocessor List, where laws regarding the protection of personal data may be less stringent than the laws in your jurisdiction.

Source: https://www.anthropic.com/legal/privacy (captured 2026-10-20)

> "Subprocessor" means an entity engaged by Anthropic to process Customer Personal Data.

Source: https://www.anthropic.com/legal/data-processing-addendum (captured 2026-10-20)

> Customer grants Anthropic general authorization to engage the Subprocessors listed in Schedule 4, and any additional Subprocessors in accordance with Section C.3. below.

Source: https://www.anthropic.com/legal/data-processing-addendum (captured 2026-10-20)

### Sources captured

- Privacy policy: https://www.anthropic.com/legal/privacy \[ok]
- Commercial terms of service: https://www.anthropic.com/legal/commercial-terms \[ok]
- Data processing addendum: https://www.anthropic.com/legal/data-processing-addendum \[ok]
- Subprocessor list: https://www.anthropic.com/subprocessors \[empty - Only 0 chars of text extracted (JS-gated page?)]

***

### Coverage, honestly

- 46 vendors, one product + plan each. Every quoted passage in the
  current packets was verified verbatim against the vendor's own
  published page: **268 of 268 quotes verified**.
- Three vendors score **0 of 6** dimensions (Oracle AI, Sourcegraph
  Cody, Windsurf). That is not missing data: their published documents
  genuinely do not address these six dimensions, and their packets say
  so, dimension by dimension.
- Capture dates are printed in every packet. A packet is a dated
  snapshot of what the vendor published on that date, not a live claim
  about the vendor's current behaviour.

### Local development

The API client (`src/verbatim_client.py`) uses only the Python standard
library, so the core logic runs without the Apify SDK:

```bash
## Smoke test against the live API; writes evidence to test-output/
python3 smoke_test.py --compare anthropic

## Full Actor locally (requires the Apify CLI and an initialized storage dir)
pip install -r requirements.txt
apify run
```

`test-output/` in this repo holds real outputs from a smoke-test run:
`list_vendors.json` (46 vendors), `get_packet-anthropic.json` (the full
Anthropic packet), `compare_packet-anthropic.json`, and `summary.json`.

### Publishing (owner checklist — not done by this repo)

1. Create/confirm an Apify account and, in Apify Console → Settings →
   Integrations, create an API token. Enter the token only through the
   secure credential flow (`apify login` or CI secret); never commit it.
2. From this directory: `apify push` (builds the Dockerfile on Apify).
3. In the Actor's Console page: set the title/description (already in
   `.actor/actor.json`), upload a logo if desired, and set the Actor to
   Public if it should appear in Apify Store.
4. Monetization tab: confirm **pay-per-event** pricing — event
   `packet-delivered` at US$0.10, `comparison-delivered` at US$0.05,
   and `bundle-delivered` at US$2.99, `list_vendors` free — matching
   `pricingInfos` in `.actor/actor.json`. Confirm platform usage is
   set to **included** in the event prices, the actor-start event is
   at its platform default, and Store discount tiers are **off**.
   While in the Console, also confirm the payout method, payout
   currency, and whether a minimum payout threshold applies.
5. Run one paid-mode test on the platform and confirm the charge event
   appears in the run's billing before announcing the listing.

### Layout

```
.actor/actor.json          Actor definition + pay-per-event pricing placeholders
.actor/input_schema.json   Console/API input form
.actor/output_schema.json  Dataset + OUTPUT declarations
.actor/dataset_schema.json Dataset fields and overview view
src/__main__.py            Entry: python3 -m src
src/main.py                Apify lifecycle: input -> API -> dataset/OUTPUT -> charge
src/verbatim_client.py     Verbatim REST client (stdlib only) + input validation
Dockerfile                 apify/actor-python:3.12
requirements.txt           apify SDK (platform runs only; the client needs nothing)
smoke_test.py              SDK-free local test against the live API
test-output/               Captured smoke-test evidence
```

# Actor input Schema

## `apiBaseUrl` (type: `string`):

Base URL of the Verbatim REST API. Leave at the default unless you run your own Verbatim instance.

## `format` (type: `string`):

Applies to get_packet only. 'json' returns the full structured packet; 'markdown' returns the rendered Markdown report.

## `mode` (type: `string`):

list_vendors: list all 46 vendors Verbatim covers (free). get_packet: the latest evidence packet for one vendor ($0.10). compare_packet: before/after changes between the two most recent captures of one vendor ($0.05, charged only when a comparison actually ran). get_all_packets: every vendor's latest packet in one run ($2.99 bundle).

## `vendorSlug` (type: `string`):

Required for get_packet and compare_packet. A slug from list_vendors, e.g. 'anthropic', 'openai', 'microsoft-azure-openai'. Lowercase letters, digits and hyphens.

## Actor input object example

```json
{
  "apiBaseUrl": "https://api.trustcyber.ca",
  "format": "json",
  "mode": "list_vendors",
  "vendorSlug": "anthropic"
}
```

# Actor output Schema

## `output` (type: `string`):

The primary result of the run, stored under the OUTPUT key in the default key-value store: the vendor list, the packet, or the comparison, in the same shape the Verbatim API returned.

## `results` (type: `string`):

Default dataset items. list_vendors: one item per vendor (slug, vendor, product, plan). get_packet: one item, the full packet (JSON mode) or a wrapper containing the Markdown text (Markdown mode). compare_packet: one item, the comparison result. get_all_packets: one packet item per vendor.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "apiBaseUrl": "https://api.trustcyber.ca",
    "format": "json",
    "mode": "list_vendors",
    "vendorSlug": "anthropic"
};

// Run the Actor and wait for it to finish
const run = await client.actor("jwtor7/verbatim-vendor-evidence").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "apiBaseUrl": "https://api.trustcyber.ca",
    "format": "json",
    "mode": "list_vendors",
    "vendorSlug": "anthropic",
}

# Run the Actor and wait for it to finish
run = client.actor("jwtor7/verbatim-vendor-evidence").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "apiBaseUrl": "https://api.trustcyber.ca",
  "format": "json",
  "mode": "list_vendors",
  "vendorSlug": "anthropic"
}' |
apify call jwtor7/verbatim-vendor-evidence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jwtor7/verbatim-vendor-evidence"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hqrf3dyFUBImfv5wK/builds/RpIsXAYgKzC3x3QbQ/openapi.json