# Apify Discoverability Audit (`shelvick/apify-discoverability-audit`) Actor Audits an Apify Actor for AI-agent discoverability against an evidence-grounded rubric. Scores 8 dimensions (agentic-pay eligibility, description quality, schema completeness, disambiguation, tool name, README, store hygiene, canonical signals) and returns a punch list with copy-paste-ready fixes. - **URL**: https://apify.com/shelvick/apify-discoverability-audit.md - **Developed by:** [Scott Helvick](https://apify.com/shelvick) (community) - **Categories:** Developer tools, MCP servers - **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing from $0.0425 / audit completed This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. 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. Actors are written with capital "A". ## 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. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## Apify Discoverability Audit Audits an Apify Actor for AI-agent discoverability against an evidence-grounded rubric. Returns a punch list of failed checks across 8 dimensions, plus copy-paste-ready improvement text for everything that didn't pass. Useful before publishing a new Actor or before requesting agentic-payment whitelisting. ### What this does Submit one Actor identifier (`username/name` or 17-char ID). The Actor fetches the target's Store metadata, its latest build (full README + parsed input schema + dataset schema), and its public Store row, then runs a deterministic 8-dimension rubric grounded in 2026 peer-reviewed research on agent tool selection. What you get back, per run: - **Overall verdict** — `PASS` / `WARN` / `FAIL` with the agentic-payment hard-gate flag broken out separately - **Per-dimension category summary** — one status per dimension (agentic-payment eligibility, description quality, schema completeness, disambiguation, tool name, README structure, store hygiene, off-platform canonical signals) - **Full punch list** — every individual check with its status, a short evidence line, and the dimension it belongs to - **Suggestions** — one copy-paste-ready improvement text per failed/warned check, written to the rubric concepts (six-component description framework, 500-char MCP truncation, 13-section README template, disambiguation block, PAY_PER_EVENT pricing) - **Warnings** — any data-collection issues (private Actor, build endpoint outage, unreachable canonical page) surfaced separately from the rubric verdicts Two outputs per successful run: - One **dataset record** with the full structured shape — the schema is on the Console's Dataset tab - A **Markdown punch list** at `OUTPUT.md` in the run's Key-Value Store — same data, rendered as a readable report Common workflows this enables: - Self-audit your Actor before pushing it public for the first time - Audit before requesting agentic-payment whitelisting (the rubric's hard gate) - Catch description-quality regressions across edits - Spot Apify build-validator gotchas (e.g. `items.enum`) before the push fails - Survey a portfolio of Actors and rank them by discoverability debt ### Why agent-discoverability matters AI agents pick tools by reading their descriptions and schemas, not by clicking through to a documentation site. Wang et al. 2026 measured a 260% lift in selection from standards-compliant tool descriptions; the "Tool Preferences in Agentic LLMs" paper found >10x usage swings from description edits alone, across multiple model families. Apify's MCP server truncates input-schema property descriptions at 500 chars before appending enum values and examples. Tools whose first 500 chars don't pre-load purpose, parameters, and constraints fail at the routing layer. Tools that miss explicit disambiguation guidance ("use [other tool] instead for [other need]") lose to similar-sounding alternatives by default. Tools that aren't on the PAY_PER_EVENT + agentic-payment whitelist are invisible to agents using x402 or Skyfire payment rails. The rubric this Actor scores is the executable form of that evidence. Pass it and your Actor competes; fail it and the agent never reaches you. ### How it compares | Approach | Description-quality rubric | Schema-completeness checks | Build-validator gotchas (items.enum, etc.) | MCP-truncation awareness | Disambiguation check | Suggestion text | |---|---|---|---|---|---|---| | Eyeballing your own Actor against the docs | ✗ | partial | ✗ | ✗ | ✗ | ✗ | | Running each schema field through a generic JSON Schema linter | ✗ | partial | ✗ | ✗ | ✗ | ✗ | | Asking an LLM "is my Actor discoverable" with the README pasted in | partial | ✗ | ✗ | ✗ | partial | partial | | **Apify Discoverability Audit** | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | The audit reads what an agent's MCP client would read — the Store row, the latest build's input schema and README — and grades it against the same rubric the writer (the apify-actor-copy skill) uses. The deterministic checks are the value; the LLM only writes the suggestion prose. ### Input | Field | Type | Required | Default | Description | |---|---|---|---|---| | `actor` | string | ✓ | — | Apify Actor to audit. Accepts `username/name` (e.g. `shelvick/smart-page-fetcher`, `apify/website-content-crawler`) or a 17-char Actor ID. | | `canonical_url` | string | | (auto-derived for `shelvick/*`) | Optional canonical-page URL for the target. When provided, the audit fetches it and checks for a Store back-link. Auto-derived to `https://www.scotthelvick.com/tools//` for the `shelvick/` namespace. | | `include_suggestions` | boolean | | `true` | When true, the LLM writes copy-paste-ready suggestion text for failed and warned checks. Set false to skip the LLM call entirely — the deterministic punch list still ships. | ### Output One dataset record per run, plus a Markdown punch list at `OUTPUT.md` in the run's Key-Value Store. Abbreviated success record: ```json { "actor": "shelvick/smart-page-fetcher", "audited_at": "2026-05-26T14:31:09Z", "overall_status": "PASS", "agentic_payment_eligible": true, "category_summary": { "agentic_payment": "PASS", "description_quality": "PASS", "schema_completeness": "PASS", "disambiguation": "PASS", "tool_name": "PASS", "readme_structure": "PASS", "store_hygiene": "PASS", "canonical_signals": "PASS" }, "checks": [ { "check_id": "description_quality.actor_description_length", "dimension": "description_quality", "status": "pass", "title": "Actor description within 100-2000 char band", "evidence": "description is 432 chars" } ], "suggestions": [], "canonical_url_checked": "https://www.scotthelvick.com/tools/smart-page-fetcher/", "warnings": [] } ```` The full schema is documented on the Console's Dataset tab. The Markdown report at `OUTPUT.md` renders the same data as a prose punch list with the verdict, per-dimension table, full check list grouped by dimension, and suggestions section. ### Example ```json { "actor": "shelvick/smart-page-fetcher", "include_suggestions": true } ``` Via the API: ```bash curl -X POST "https://api.apify.com/v2/acts/shelvick~apify-discoverability-audit/run-sync-get-dataset-items?token=YOUR_TOKEN" \ -H "Content-Type: application/json" \ -d '{"actor": "shelvick/smart-page-fetcher"}' ``` A typical audit returns in 10-30 seconds — fast enough for the synchronous endpoint. ### Calling from an AI agent The Actor is designed for agent discovery and invocation. **MCP** (`mcp.apify.com`): surfaces as a callable tool. The input schema is self-documenting — one required field (`actor`), structured output, no follow-up questions. An LLM can construct correct calls from the tool description without external context. Pay per call via the Actor's pay-per-event model — works with x402 and Skyfire agentic-payment rails. **Apify SDK** (Python): ```python from apify_client import ApifyClient client = ApifyClient(token=API_TOKEN) run = client.actor("shelvick/apify-discoverability-audit").call( run_input={"actor": "shelvick/smart-page-fetcher"} ) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item["overall_status"], item["category_summary"]) ``` **REST**: `/run-sync-get-dataset-items` for the typical 10-30 second run, the async `/runs` endpoint for very large targets (uncommon — audit work doesn't scale with target size). ### Pricing Pay-per-event. Flat rate: a single `audit-completed` charge per successful run. The platform-startup charge fires once regardless of outcome but is effectively zero. Failed runs (invalid input, target Actor unreachable) skip the audit charge entirely. Setting `include_suggestions=false` skips the LLM call but the audit charge is the same — the deterministic punch list is the costed work. See the **Pricing** tab on this Store page for the current per-event rate and any active subscriber discounts. ### Behavior #### Failure modes The run is marked **FAILED** only on input validation: - `actor` empty or below 3 chars - `actor` not matching `username/name` or a 17-char ID - The target Actor's `/v2/acts/` endpoint returns 404 / 403 / 500 When the target fetch fails, no audit charge fires. Per-source data-collection issues don't fail the run; they degrade silently and add entries to the `warnings` array. Common warnings: - `pricing-data-unavailable` — pricingInfos was absent from the target's Actor object (we don't own the Actor, or it's unpriced) AND no public Store row matched. The agentic-payment dimension warns rather than fails when this happens (eligibility can't be confirmed from outside), and `agentic_payment_eligible` is reported as `null`. - `build-fetch-failed: ` — the latest build endpoint returned an error. README, input schema, and dataset schema fall back to empty; the dimensions that depend on them report failures. - `canonical-non-200: → ` — the canonical page fetch returned 4xx or 5xx. The canonical-signals dimension warns rather than fails. - `inputSchema-parse-failed: ` — the build endpoint returned an unparseable inputSchema string. Schema-completeness checks fall back as if the schema were absent. #### Performance expectations 10-30 seconds typical wall-clock. Three sequential Apify API calls (Actor object, default build, Store search) plus zero or one canonical-page fetch and zero or one LLM call. No browser tier, no proxy, no recursive fetching. The default `run-sync-get-dataset-items` endpoint (180-second sync cap) handles every audit comfortably. ### FAQ **What's the rubric grounded in?** A 2026-05-26 forge:researcher brief synthesizing peer-reviewed agent-tool-selection research: Wang et al. 2026 on description-quality lift, "Tool Preferences in Agentic LLMs" on usage-swings from description edits, BiasBusters on semantic-alignment as the dominant selection driver, and Anthropic engineering guidance on description quality plus disambiguation as the highest-impact surfaces. JSON-LD and llms.txt are NOT load-bearing per Search Atlas's 2025 300K-domain LLM-citation study and Limy's 2025 90-day bot-traffic log study — both showed null/negligible citation effect. Those signals are scored as hygiene only. **Can I audit a private Actor before publishing?** Yes for Actors you own. The Apify token injected by the platform gives the audit access to your own private Actors, including pricingInfos and agentic-payment whitelist status (the Actor-object endpoint exposes these for owned Actors regardless of publish state). For other users' public Actors, the audit falls back to the Store search; if that doesn't find them (newly-published Actors sometimes don't index), the agentic-payment dimension reports WARN and `agentic_payment_eligible` is `null` — unconfirmed, not disqualifying. **Why does the LLM only write suggestion text?** Every verdict (pass/warn/fail) comes from deterministic checks against the fetched metadata. LLM-as-scorer on subjective categories produces unauditable results. The LLM here only synthesizes copy-paste-ready prose for already-failed checks — it can't invent dimensions or change verdicts. **What if I disagree with a check's verdict?** The check\_ids are stable strings (e.g. `description_quality.actor_description_length`). Inspect the source — every check is a pure function in the public Actor repo. Open an issue or PR if the rubric is wrong; the standards live in `actorlib.discoverability_standards` for portability. **Does the audit charge run on failure?** No. The audit-completed charge fires only on a successful audit. Input-validation failures and target-fetch failures skip it entirely. The platform-startup charge fires regardless but is effectively zero. ### What this doesn't do - **No batch input.** One Actor per run. Run several and diff the dataset records offline. - **No automatic fixing.** The audit reports what to change and writes suggestion prose; it doesn't push edits back to your Actor. - **No live MCP probing.** The rubric grades the metadata an MCP agent would read, but the audit itself doesn't simulate an agent's selection flow end-to-end. - **No subjective taste.** Brand voice, marketing positioning, persona fit — none of that is graded. The rubric is mechanical. - **No private data inspection.** Only the public Apify API and (if you opt in) the canonical page URL you provide. For one-shot improvement of an existing Actor's customer-facing copy, use the `apify-actor-copy` writing skill instead — it writes against the same standards this Actor audits against. For ongoing tracking of a portfolio's discoverability over time, run this audit on a cron and diff the dataset records. For competitive landscape analysis against other published Actors, use a dedicated Store-search workflow. *** Design notes: [scotthelvick.com/tools/apify-discoverability-audit](https://www.scotthelvick.com/tools/apify-discoverability-audit/) # Actor input Schema ## `actor` (type: `string`): Apify Actor to audit. Accepts either 'username/name' (e.g. 'shelvick/smart-page-fetcher', 'apify/website-content-crawler') or a 17-char Actor ID. Required. The audit fetches the Actor's Store metadata, latest build (input schema + dataset schema + full README), and Store row (pricing model + agentic-payment whitelist flag), then runs the deterministic 8-dimension rubric and returns a punch list. ## `canonical_url` (type: `string`): Optional canonical-page URL for this Actor (e.g. 'https://www.scotthelvick.com/tools/smart-page-fetcher/'). If provided, the audit fetches it and checks for a Store back-link (Store ↔ canonical cross-link is the highest-leverage off-platform GEO signal). If absent AND the target is in the shelvick/ namespace, the audit auto-derives 'https://www.scotthelvick.com/tools//'. Leave blank for any Actor without a canonical page. ## `include_suggestions` (type: `boolean`): Whether to invoke the LLM to generate copy-paste-ready improvement text for failed and warned checks. Default true. Set false to skip the LLM call entirely — the audit still runs all 8 deterministic dimensions and returns the punch list with evidence, just without prose suggestions. Faster and cheaper when you only need the pass/fail signal. ## Actor input object example ```json { "actor": "shelvick/smart-page-fetcher", "include_suggestions": true } ``` # Actor output Schema ## `audit_record` (type: `string`): The full AuditResult JSON pushed to the run's default dataset. One record per successful audit, matching the dataset\_schema.json contract. ## `punch_list_markdown` (type: `string`): Human- and agent-readable Markdown rendering of the audit result. Verdict, per-dimension summary table, full check list grouped by dimension, suggestions, and warnings. ## `target_metadata_json` (type: `string`): Snapshot of everything the audit fetched about the target Actor — Store row, Actor object, parsed input/dataset schemas, README, canonical-page HTML if present. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "actor": "shelvick/smart-page-fetcher", "include_suggestions": true }; // Run the Actor and wait for it to finish const run = await client.actor("shelvick/apify-discoverability-audit").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "actor": "shelvick/smart-page-fetcher", "include_suggestions": True, } # Run the Actor and wait for it to finish run = client.actor("shelvick/apify-discoverability-audit").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "actor": "shelvick/smart-page-fetcher", "include_suggestions": true }' | apify call shelvick/apify-discoverability-audit --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=shelvick/apify-discoverability-audit", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Apify Discoverability Audit", "description": "Audits an Apify Actor for AI-agent discoverability against an evidence-grounded rubric. Scores 8 dimensions (agentic-pay eligibility, description quality, schema completeness, disambiguation, tool name, README, store hygiene, canonical signals) and returns a punch list with copy-paste-ready fixes.", "version": "0.0", "x-build-id": "1YH97RMKZcqWFH9c4" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/shelvick~apify-discoverability-audit/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-shelvick-apify-discoverability-audit", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/shelvick~apify-discoverability-audit/runs": { "post": { "operationId": "runs-sync-shelvick-apify-discoverability-audit", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/shelvick~apify-discoverability-audit/run-sync": { "post": { "operationId": "run-sync-shelvick-apify-discoverability-audit", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "required": [ "actor" ], "properties": { "actor": { "title": "Actor to audit", "minLength": 3, "maxLength": 200, "type": "string", "description": "Apify Actor to audit. Accepts either 'username/name' (e.g. 'shelvick/smart-page-fetcher', 'apify/website-content-crawler') or a 17-char Actor ID. Required. The audit fetches the Actor's Store metadata, latest build (input schema + dataset schema + full README), and Store row (pricing model + agentic-payment whitelist flag), then runs the deterministic 8-dimension rubric and returns a punch list." }, "canonical_url": { "title": "Canonical documentation URL (optional)", "type": "string", "description": "Optional canonical-page URL for this Actor (e.g. 'https://www.scotthelvick.com/tools/smart-page-fetcher/'). If provided, the audit fetches it and checks for a Store back-link (Store ↔ canonical cross-link is the highest-leverage off-platform GEO signal). If absent AND the target is in the shelvick/ namespace, the audit auto-derives 'https://www.scotthelvick.com/tools//'. Leave blank for any Actor without a canonical page." }, "include_suggestions": { "title": "Include LLM-generated suggestion text", "type": "boolean", "description": "Whether to invoke the LLM to generate copy-paste-ready improvement text for failed and warned checks. Default true. Set false to skip the LLM call entirely — the audit still runs all 8 deterministic dimensions and returns the punch list with evidence, just without prose suggestions. Faster and cheaper when you only need the pass/fail signal.", "default": true } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```