# URL Health ❤️‍🩹 — URL & SSL Health Checker (Batch) (`perryay/url-health`) Actor Comprehensive URL health checker with batch support. Tests HTTP status codes, response times, redirect chains, SSL certificate validity, and content-type detection. Check up to 20 URLs in a single run. - **URL**: https://apify.com/perryay/url-health.md - **Developed by:** [Perry AY](https://apify.com/perryay) (community) - **Categories:** Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.01 / actor start This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. 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/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 ## URL Health ❤️‍🩹 — URL & SSL Health Checker (Batch) **Comprehensive URL diagnostics: HTTP status codes, response times, redirect chain analysis, SSL/TLS certificate validation, and content-type detection — for up to 20 URLs in a single run.** Your application's reliability depends on the services it calls. A single failing upstream endpoint can cascade into degraded user experience, broken integrations, and revenue loss. **URL Health** provides a complete diagnostic check for any URL with zero configuration: it follows redirects, measures response latency, inspects TLS certificates, and detects content types — all with clear, structured output. Batch up to 20 URLs in a single run for monitoring fleets of endpoints, verifying CDN configurations, or auditing link health across your entire web property. Every result includes a full audit trail: HTTP status code, response time in milliseconds, redirect chain with intermediate status codes, SSL certificate details (issuer, subject, validity period, SANs), server header, and content length. --- ### ✨ Features - **Batch URL processing** — Check up to 20 URLs in a single run with independent diagnostics per URL; individual failures never block the batch - **HTTP status code validation** — Returns the exact HTTP status code (200, 301, 404, 500, etc.) for every checked URL, enabling precise monitoring and alerting - **Response time measurement** — Precise elapsed time in milliseconds for each request, useful for performance monitoring and SLO tracking - **Redirect chain tracing** — Records the full redirect path with source URL, destination URL, and intermediate status codes for every hop — critical for detecting redirect loops and broken intermediates - **SSL/TLS certificate validation** — For HTTPS URLs, connects to the origin server, validates the TLS certificate, and returns certificate subject, issuer, validity dates, and Subject Alternative Names (SANs) - **Content-type detection** — Reports the `Content-Type` header from the response, enabling verification of MIME types, charset, and media format expectations - **Content-length measurement** — Returns the response body size in bytes for bandwidth planning and response completeness checks - **Server header capture** — Records the `Server` response header for infrastructure fingerprinting and CDN identification - **Configurable timeout** — Adjustable per-request timeout (1–60 seconds) for slow endpoints, with graceful timeout error handling - **Redirect following control** — Toggle automatic redirect following with the `follow_redirects` parameter (default: on) ### 🚀 Quick Start #### Single URL — Basic Health Check **Input:** ```json { "url": "https://example.com" } ```` #### Batch URL Check — Multiple Endpoints **Input:** ```json { "urls": [ "https://example.com", "https://google.com", "https://github.com", "https://httpstat.us/404", "https://httpstat.us/500" ], "timeout": 10 } ``` #### Single URL with SSL Inspection **Input:** ```json { "urls": ["https://example.com"], "follow_redirects": true, "timeout": 15 } ``` **Response:** ```json { "url": "https://example.com", "http": { "url": "https://example.com", "status_code": 200, "response_ms": 45.2, "content_type": "text/html; charset=utf-8", "content_length": 1256, "server": "ECS (dcb/7EFA)" }, "ssl": { "valid": true, "hostname": "example.com", "subject": { "commonName": "example.com", "organizationName": "Internet Corporation for Assigned Names and Numbers" }, "issuer": { "organizationName": "DigiCert Inc", "commonName": "DigiCert TLS RSA SHA256 2020 CA1" }, "not_before": "Jan 1 00:00:00 2026 GMT", "not_after": "Jan 1 00:00:00 2027 GMT", "sans": ["example.com", "www.example.com"] }, "timestamp": 1712345678.123 } ``` #### URL with Redirect Chain **Input:** ```json { "urls": ["https://httpstat.us/301"] } ``` **Response (http section):** ```json { "status_code": 200, "response_ms": 112.4, "content_type": "text/plain", "content_length": 0, "server": "Microsoft-IIS/10.0", "redirects": [ { "from": "https://httpstat.us/301", "to": "https://httpstat.us/", "status_code": 301 } ], "final_url": "https://httpstat.us/" } ``` ### 📋 Input Parameters | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `url` | string | `""` | Single URL to check. Alternative to `urls` array for single-URL usage. | | `urls` | array | `[]` | Array of URLs to check (up to 20). Overrides `url` when both are provided. | | `timeout` | integer | `10` | Request timeout in seconds per URL (range: 1–60). | | `follow_redirects` | boolean | `true` | Whether to automatically follow HTTP redirects. Disable to check redirect targets explicitly. | ### 📤 Output Format Each checked URL produces one result row: #### Top-Level Fields | Field | Type | Description | |-------|------|-------------| | `url` | string | The URL that was checked | | `http` | object | HTTP diagnostics object (see below) | | `ssl` | object | SSL/TLS certificate object (present only for HTTPS URLs) | | `timestamp` | number | Unix timestamp of when the check was performed | #### HTTP Diagnostics (`http` object) | Field | Type | Description | |-------|------|-------------| | `url` | string | Original URL checked | | `status_code` | integer | HTTP status code (200, 301, 404, 500, etc.) | | `response_ms` | number | Response time in milliseconds | | `content_type` | string | Content-Type response header value | | `content_length` | integer | Response body size in bytes | | `server` | string | Server response header value | | `redirects` | array | Array of redirect objects (only when redirects were followed) | | `redirects[].from` | string | Source URL before redirect | | `redirects[].to` | string | Destination URL after redirect | | `redirects[].status_code` | integer | Intermediate HTTP status code | | `final_url` | string | Final URL after all redirects (only when redirects were followed) | | `error` | string | Error message if the request failed | #### SSL/TLS Certificate (`ssl` object) | Field | Type | Description | |-------|------|-------------| | `valid` | boolean | Whether a valid TLS certificate was received | | `hostname` | string | Hostname checked | | `subject` | object | Certificate subject fields (commonName, organizationName, etc.) | | `issuer` | object | Certificate issuer fields (commonName, organizationName, etc.) | | `not_before` | string | Certificate validity start date (GMT) | | `not_after` | string | Certificate expiry date (GMT) | | `sans` | array | Subject Alternative Names (DNS names and IPs covered) | | `error` | string | SSL error description if certificate validation failed | A `_summary` row is appended with `total` URLs checked, `success_count` (status < 400), and `batch` flag. ### 📖 Usage Examples #### cURL (Apify API) ```bash ## Single URL curl -X POST "https://api.apify.com/v2/acts/perryay~url-health/runs" \ -H "Content-Type: application/json" \ -H "Authorization: Bearer YOUR_API_TOKEN" \ -d '{"url": "https://example.com"}' ## Batch URLs curl -X POST "https://api.apify.com/v2/acts/perryay~url-health/runs" \ -H "Content-Type: application/json" \ -H "Authorization: Bearer YOUR_API_TOKEN" \ -d '{"urls": ["https://example.com", "https://google.com"], "timeout": 15}' ``` #### Python (Apify SDK) ```python from apify_client import ApifyClient client = ApifyClient("YOUR_API_TOKEN") ## Check multiple URLs result = client.actor("perryay~url-health").call( run_input={ "urls": [ "https://example.com", "https://google.com", "https://httpstat.us/404", "https://self-signed.badssl.com", ], "timeout": 10, } ) dataset = client.dataset(result["defaultDatasetId"]).list_items() for item in dataset.items: if item.get("_summary"): print(f"Summary: {item['success_count']}/{item['total']} healthy") continue http = item.get("http", {}) status = http.get("status_code", "?") ms = http.get("response_ms", "?") err = http.get("error", "") print(f"{item['url']} → {status} ({ms}ms)") if err: print(f" Error: {err}") if item.get("ssl"): ssl_valid = item["ssl"].get("valid", False) issuer = item["ssl"].get("issuer", {}).get("organizationName", "?") print(f" SSL: {'✅' if ssl_valid else '❌'} (Issuer: {issuer})") ``` #### JavaScript / Node.js (Apify SDK) ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_API_TOKEN' }); const result = await client.actor('perryay~url-health').call({ urls: ['https://example.com', 'https://google.com'], timeout: 10, }); const { items } = await client.dataset(result.defaultDatasetId).listItems(); for (const item of items) { if (item._summary) { console.log(`Summary: ${item.success_count}/${item.total} healthy`); continue; } const http = item.http || {}; console.log(`${item.url} → ${http.status_code} (${http.response_ms}ms)`); if (item.ssl) { console.log(` SSL Valid: ${item.ssl.valid}`); } } ``` ### 🎯 Use Cases - **Uptime monitoring** — Periodically check critical endpoints (API gateways, SaaS integrations, payment processors) and alert on non-2xx status codes or degraded response times - **CDN and caching verification** — Verify that CDN origins, edge nodes, and cached content serve correct status codes, proper content types, and valid SSL certificates across global regions - **SSL certificate expiry tracking** — Monitor the `not_after` field across your entire domain portfolio to proactively renew certificates before they expire and cause browser warnings or service interruptions - **Link rot detection** — Scan all external links on your website or documentation for broken URLs (404, 410, 5xx) and maintain link quality over time - **Redirect chain auditing** — Audit partner redirect URLs, affiliate links, and URL shorteners to ensure they resolve to the correct destination without unnecessary hops or broken intermediates - **API contract verification** — Verify that third-party API endpoints return expected status codes, content types, and response headers after deployments or API version upgrades - **Infrastructure migration validation** — After migrating domains, load balancers, or CDN providers, batch-check all affected URLs to confirm the migration completed without errors - **Content-type compliance checking** — Ensure all assets on your site serve correct MIME types (e.g., JavaScript as `application/javascript`, CSS as `text/css`) to prevent browser warnings and rendering issues ### ❓ FAQ **Q: How many URLs can I check in one run?** A: Up to 20 URLs. Each URL is checked independently, so a timeout or error on one URL never blocks the others. **Q: Does this actor follow redirects?** A: Yes, by default. Set `follow_redirects: false` to disable redirect following and only check the initial URL. When enabled, the full redirect chain is recorded in the `redirects` array. **Q: What SSL/TLS information is returned?** A: The actor performs a real TLS handshake with the origin server and returns certificate subject, issuer organization, validity dates (`not_before`/`not_after`), and all Subject Alternative Names (SANs). SSL checks are only performed for `https://` URLs. **Q: Can this detect self-signed or expired certificates?** A: Yes. If the SSL certificate is invalid (expired, self-signed, wrong hostname), the `ssl.valid` field will be `false` and the `ssl.error` field will contain the specific validation error message. **Q: What response time is considered good?** A: For web pages, under 200ms is excellent, 200-500ms is acceptable, and over 1 second needs investigation. For APIs, under 100ms is excellent, 100-300ms is acceptable. The actor reports precise millisecond timing for each request. **Q: How are errors handled during batch processing?** A: Each URL is checked independently. Timeouts, connection errors, SSL errors, and invalid URLs are all caught per-URL without affecting other URLs in the batch. The error message is included in the `http.error` field. **Q: Does this actor support non-HTTP protocols?** A: No. Only `http://` and `https://` URLs are supported. Other protocols (FTP, SSH, SMTP) should use protocol-specific tools. **Q: Can I use this for internal/private endpoints?** A: The actor runs on Apify infrastructure. If your private endpoints are not accessible from the public internet, the actor will not be able to reach them. Consider running the actor in a private Apify platform network or using a dedicated proxy. **Q: What does the `server` header tell me?** A: The `Server` HTTP response header reveals the web server software (nginx, Apache, Cloudflare, ECS, etc.). This is useful for infrastructure fingerprinting and verifying CDN or reverse proxy configuration. ### 🛠 Tips & Best Practices - **Set appropriate timeouts** — Start with the default 10-second timeout and adjust based on your endpoints. Very slow endpoints (over 30 seconds) may indicate performance problems worth investigating separately. - **Monitor SSL expiry proactively** — Set up regular batch checks of your domains and alert when `days_remaining` (computed from `ssl.not_after`) falls below 30 days. This gives you a full month to handle renewals. - **Use redirect chain for SEO audits** — Excessive redirect hops waste page authority and slow down user experience. The `redirects` array shows every hop — ideally no more than 2 redirects between the initial URL and the final destination. - **Batch strategically** — Group URLs by expected latency: check fast CDN-served assets together with a short timeout, and check slower dynamic endpoints with a longer timeout. This prevents slow endpoints from delaying rapid-feedback monitoring. - **Track response times over time** — Log `response_ms` values into a time-series database to establish baselines and detect performance regressions. A sudden 2x increase in response time often indicates upstream issues before they cause failures. - **Combine with other actors** — Use this actor in pipelines with SSL Certificate Checker for deep certificate chain analysis, or with Link Quality Analyzer for comprehensive SEO health assessments. - **Validate redirect destinations** — The `final_url` field shows where you actually end up after all redirects. Compare this against your expected destination to catch hijacked redirects, expired URL shorteners, or misconfigured proxies. ### 🩺 Diagnostic Summary The `_summary` row appended at the end of each batch run provides: ```json { "_summary": true, "total": 4, "success_count": 3, "batch": true } ``` - `total` — Number of URLs checked - `success_count` — URLs returning HTTP status < 400 (healthy) - `batch` — Always `true` when multiple URLs are checked Use the ratio `success_count / total` as a quick service health indicator. ### 🌐 Protocol and Port Support | Scheme | Supported | SSL Check | Notes | |--------|-----------|-----------|-------| | `http://` | ✅ | ❌ | Standard HTTP check, no port restrictions | | `https://` | ✅ | ✅ | Full TLS handshake with certificate validation | | Port in URL | ✅ | N/A | Custom ports supported via URL (e.g. `https://example.com:8443`) | *** ### 🔗 Related Tools Check out other developer utilities by [perryay](https://apify.com/perryay): | Tool | Description | |------|-------------| | [JSON Studio](https://apify.com/perryay/json-studio) | Format, validate, transform, and diff JSON data with 8 operation modes | | [QR Craft](https://apify.com/perryay/qr-craft) | Generate high-quality QR codes in PNG or SVG, batch up to 50 | | [UUID Lab](https://apify.com/perryay/uuid-lab) | Generate UUID v4/v7, NanoID, Short ID, and ULID identifiers | | [Domain Intel](https://apify.com/perryay/domain-intel) | WHOIS, DNS, and SSL lookup for domain intelligence | | [Meta Mate](https://apify.com/perryay/meta-mate) | Extract Open Graph, Twitter Cards, and JSON-LD metadata | | [IP Geo](https://apify.com/perryay/ip-geo) | Multi-provider IP geolocation with ISP detection | | [URL Health](https://apify.com/perryay/url-health) | Check URL accessibility, redirects, and SSL health | | [PW Forge](https://apify.com/perryay/pw-forge) | Generate secure passwords with entropy calculation | | [TZ Mate](https://apify.com/perryay/tz-mate) | Convert timezones and check DST offsets | | [Regex Lab](https://apify.com/perryay/regex-lab) | Test and debug regular expressions online | | [Brand Monitor Lite](https://apify.com/perryay/brand-monitor-lite) | Track brand mentions across multiple URLs | | [Link Quality Analyzer](https://apify.com/perryay/link-quality-analyzer) | Detect broken links and audit link quality | | [Mock Data Generator](https://apify.com/perryay/mock-data-generator) | Generate realistic test data for development | | [HTML to Markdown](https://apify.com/perryay/html-to-markdown) | Convert web pages or HTML to clean Markdown | | [SSL Cert Inspector](https://apify.com/perryay/ssl-cert-inspector) | Deep SSL/TLS certificate analysis with scoring | # Actor input Schema ## `url` (type: `string`): Single URL to check (e.g. https://example.com). Leave empty if using batch mode. ## `urls` (type: `array`): Multiple URLs to check in one run (up to 20). Overrides 'url' if set. ## `timeout` (type: `integer`): Request timeout per URL ## `follow_redirects` (type: `boolean`): Follow HTTP redirects ## Actor input object example ```json { "urls": [ "https://example.com", "https://google.com", "https://github.com" ], "timeout": 10, "follow_redirects": true } ``` # Actor output Schema ## `results` (type: `string`): Per-URL health check results in the default dataset # 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 = { "urls": [ "https://example.com", "https://google.com", "https://github.com" ] }; // Run the Actor and wait for it to finish const run = await client.actor("perryay/url-health").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 = { "urls": [ "https://example.com", "https://google.com", "https://github.com", ] } # Run the Actor and wait for it to finish run = client.actor("perryay/url-health").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 '{ "urls": [ "https://example.com", "https://google.com", "https://github.com" ] }' | apify call perryay/url-health --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=perryay/url-health", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "URL Health ❤️‍🩹 — URL & SSL Health Checker (Batch)", "description": "Comprehensive URL health checker with batch support. Tests HTTP status codes, response times, redirect chains, SSL certificate validity, and content-type detection. Check up to 20 URLs in a single run.", "version": "1.0", "x-build-id": "tuXoKewxsKgXODN6Y" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/perryay~url-health/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-perryay-url-health", "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/perryay~url-health/runs": { "post": { "operationId": "runs-sync-perryay-url-health", "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/perryay~url-health/run-sync": { "post": { "operationId": "run-sync-perryay-url-health", "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", "properties": { "url": { "title": "URL (single)", "type": "string", "description": "Single URL to check (e.g. https://example.com). Leave empty if using batch mode." }, "urls": { "title": "URLs (batch)", "type": "array", "description": "Multiple URLs to check in one run (up to 20). Overrides 'url' if set." }, "timeout": { "title": "Timeout (seconds)", "type": "integer", "description": "Request timeout per URL", "default": 10 }, "follow_redirects": { "title": "Follow Redirects", "type": "boolean", "description": "Follow HTTP redirects", "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 } } } } } } } } } } ```