# SSL Certificate Checker (`perryay/ssl-certificate-checker`) Actor Check SSL/TLS certificate details for one or more domains. Retrieves issuer, subject, validity dates, cipher info, and chain analysis. - **URL**: https://apify.com/perryay/ssl-certificate-checker.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.015 / 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 ## SSL Certificate Checker — Check SSL/TLS Certificate Details for Any Domain **Check SSL/TLS certificate details for one or more domains. Retrieve issuer, subject, validity dates, Subject Alternative Names (SANs), cipher suite information, certificate chain analysis, and expiry warnings in a single API call.** --- ### What does it do? SSL Certificate Checker connects to one or more target domains over TLS and retrieves the full certificate chain presented during the handshake. For each domain, it extracts and analyses every certificate in the chain — from the leaf certificate down to the root CA — and returns detailed information including issuer and subject identities, validity period (notBefore / notAfter), Subject Alternative Names (SANs), signature algorithm, key strength, and the TLS cipher suite negotiated during the handshake. The actor provides built-in expiry warnings that flag certificates expiring within configurable thresholds (e.g., 14 days, 30 days, 90 days). Chain analysis identifies missing intermediate certificates, untrusted roots, and other chain completeness issues. Batch mode allows checking multiple domains in a single run, making it ideal for organisations managing dozens or hundreds of TLS endpoints. --- ### Who is it for? This actor is designed for: - **DevOps and SRE teams** responsible for managing TLS certificate lifecycle across many services. - **Security engineers** auditing certificate hygiene, weak cipher support, and chain validity across the organisation. - **Site reliability engineers** monitoring certificate expiry to prevent outages caused by expired certificates. - **Penetration testers** evaluating TLS configuration strength as part of security assessments. - **Compliance officers** who need periodic evidence of proper TLS configuration for regulatory audits (PCI DSS, HIPAA, GDPR). - **Web hosting and domain administrators** managing certificates across multiple client or internal domains. --- ### Why use this? **Full chain analysis, not just the leaf.** Many certificate checkers stop at the leaf certificate. This actor traverses the entire chain, identifying missing intermediate certificates, outdated root stores, and chain ordering issues that can cause trust failures on older clients. **Expiry warnings you can act on.** Set your own warning thresholds and get clear, actionable expiry status for each certificate. Never be caught off guard by an expired certificate taking down a production service. **Cipher suite transparency.** See exactly which TLS version and cipher suite was negotiated. Identify services still supporting TLS 1.0 or 1.1, weak ciphers (RC4, 3DES), or outdated key exchange methods. **Batch mode for fleet-wide checks.** Submit multiple domains in a single run and receive a consolidated report. Perfect for organisations managing certificates across dozens of subdomains, microservices, or customer-facing endpoints. **SAN enumeration.** See every Subject Alternative Name in the certificate at a glance. Catch certificates that include unexpected domains (potential misissuance) or that are missing expected domains (potential trust errors). --- ### Input Parameters | Parameter | Type | Required | Default | Description | |-----------|------|----------|---------|-------------| | `domains` | array | Yes | — | Array of domain names to check (e.g., `["example.com", "api.example.com", "admin.example.com"]`). Accepts hostnames and IP addresses. | | `timeoutSecs` | number | No | `10` | Connection timeout per domain in seconds. Increase for slow-responding or high-latency targets. | --- ### Example Input **Single domain check:** ```json { "domains": ["example.com"], "timeoutSecs": 10 } ```` **Batch certificate audit:** ```json { "domains": [ "example.com", "api.example.com", "admin.example.com", "mail.example.com", "cdn.example.com" ], "timeoutSecs": 15 } ``` *** ### Output Structure The actor returns a JSON object with results for each domain. Each domain result contains the leaf certificate details, chain information, and expiry analysis. | Field | Type | Description | |-------|------|-------------| | `domain` | string | The domain that was checked | | `resolvedIp` | string | IP address the domain resolved to | | `connected` | boolean | Whether a TLS connection was successfully established | | `error` | string | Error message if connection failed | | `certificate` | object | Leaf certificate details | | `certificate.subject` | object | Subject fields (CN, O, OU, L, ST, C) | | `certificate.issuer` | object | Issuer fields | | `certificate.serialNumber` | string | Certificate serial number | | `certificate.notBefore` | string | Validity start (ISO 8601) | | `certificate.notAfter` | string | Validity end / expiry date (ISO 8601) | | `certificate.daysRemaining` | number | Days until expiry | | `certificate.expiryStatus` | string | `"valid"`, `"expiring_soon"`, `"expiring_critical"`, or `"expired"` | | `certificate.signatureAlgorithm` | string | Signature algorithm (e.g., `sha256WithRSAEncryption`) | | `certificate.keySize` | number | Public key size in bits | | `certificate.sans` | array | Subject Alternative Names (DNS names) | | `certificate.selfSigned` | boolean | Whether the certificate is self-signed | | `certificate.isCA` | boolean | Whether the certificate is a CA certificate | | `tlsVersion` | string | Negotiated TLS version (e.g., `TLSv1.3`, `TLSv1.2`) | | `cipherSuite` | string | Negotiated cipher suite (e.g., `TLS_AES_256_GCM_SHA384`) | | `chain` | array | Full certificate chain from leaf to root | | `chain[].subject` | object | Subject of each chain certificate | | `chain[].issuer` | object | Issuer of each chain certificate | | `chain[].notAfter` | string | Expiry date of each chain certificate | | `chain[].selfSigned` | boolean | True for root CA (self-signed) | | `chainIssues` | array | Any issues found with the certificate chain | | `warnings` | array | Security warnings (weak cipher, short key, etc.) | *** ### Example Output ```json { "results": [ { "domain": "example.com", "resolvedIp": "93.184.216.34", "connected": true, "certificate": { "subject": { "CN": "www.example.org", "O": "Internet Corporation for Assigned Names and Numbers", "L": "Los Angeles", "ST": "California", "C": "US" }, "issuer": { "CN": "DigiCert TLS RSA SHA256 2020 CA1", "O": "DigiCert Inc", "C": "US" }, "serialNumber": "0F:E8:9A:7B:2C:4D:5E:6F:1A:2B:3C:4D:5E:6F:7A:8B", "notBefore": "2024-06-01T00:00:00.000Z", "notAfter": "2025-06-01T23:59:59.000Z", "daysRemaining": 120, "expiryStatus": "valid", "signatureAlgorithm": "sha256WithRSAEncryption", "keySize": 2048, "sans": [ "www.example.org", "example.org", "example.com", "www.example.com" ], "selfSigned": false, "isCA": false }, "tlsVersion": "TLSv1.3", "cipherSuite": "TLS_AES_256_GCM_SHA384", "chain": [ { "subject": { "CN": "www.example.org" }, "issuer": { "CN": "DigiCert TLS RSA SHA256 2020 CA1" }, "notAfter": "2025-06-01T23:59:59.000Z", "selfSigned": false }, { "subject": { "CN": "DigiCert TLS RSA SHA256 2020 CA1" }, "issuer": { "CN": "DigiCert Global Root CA" }, "notAfter": "2030-11-09T23:59:59.000Z", "selfSigned": false }, { "subject": { "CN": "DigiCert Global Root CA" }, "issuer": { "CN": "DigiCert Global Root CA" }, "notAfter": "2031-11-09T23:59:59.000Z", "selfSigned": true } ], "chainIssues": [], "warnings": [] } ] } ``` *** ### API Usage #### cURL ```bash ## Check a single domain curl -X POST "https://api.apify.com/v2/acts/perryay~ssl-certificate-checker/runs" \ -H "Content-Type: application/json" \ -d '{ "domains": ["example.com"], "timeoutSecs": 10 }' ## Batch check multiple domains curl -X POST "https://api.apify.com/v2/acts/perryay~ssl-certificate-checker/runs" \ -H "Content-Type: application/json" \ -d '{ "domains": ["example.com", "api.example.com", "admin.example.com"], "timeoutSecs": 15 }' ``` #### Python ```python import requests from datetime import datetime API_TOKEN = "YOUR_API_TOKEN" ACTOR_ID = "perryay~ssl-certificate-checker" ## Check domains payload = { "domains": ["example.com", "api.example.com", "admin.example.com"], "timeoutSecs": 15 } response = requests.post( f"https://api.apify.com/v2/acts/{ACTOR_ID}/runs", params={"token": API_TOKEN}, json=payload ) results = response.json() ## Generate expiry report print("Certificate Expiry Report") print("=" * 60) for cert_result in results["results"]: domain = cert_result["domain"] if not cert_result.get("connected"): print(f"⛔ {domain} - Connection failed: {cert_result.get('error', 'Unknown error')}") continue cert = cert_result["certificate"] status = cert["expiryStatus"] days = cert["daysRemaining"] status_icon = "✅" if status == "valid" else "⚠️" if "expiring" in status else "❌" print(f"{status_icon} {domain} ({cert['sans'][0]})") print(f" Issuer: {cert['issuer']['CN']}") print(f" Expires: {cert['notAfter'][:10]} ({days} days remaining)") print(f" TLS: {cert_result['tlsVersion']} | Cipher: {cert_result['cipherSuite']}") print(f" Key: {cert['keySize']}-bit {cert['signatureAlgorithm']}") for warning in cert_result.get("warnings", []): print(f" ⚠ {warning}") for issue in cert_result.get("chainIssues", []): print(f" ⛔ Chain issue: {issue}") print() ## Find expiring certificates print("\n=== Certificates needing attention ===") for cert_result in results["results"]: if not cert_result.get("connected"): continue cert = cert_result["certificate"] if cert["expiryStatus"] != "valid": print(f" {cert_result['domain']} - expires {cert['notAfter'][:10]} ({cert['daysRemaining']} days)") ``` *** ### Use Cases #### Automated certificate expiry monitoring Run the actor on a weekly schedule to scan all your production domains. Generate a report of every certificate expiring within 30 days and trigger alerts to the team responsible for renewal. Eliminate certificate-related outages entirely. #### TLS configuration audit Audit your entire domain portfolio for TLS version support. Identify services still running TLS 1.0 or 1.1 that need to be upgraded. Flag weak cipher suites (RC4, 3DES, CBC-mode ciphers) and short key sizes (1024-bit RSA or less). Generate a compliance-ready report for auditors. #### Certificate chain validation Detect chain issues before they cause trust errors in production. Identify missing intermediate certificates that older clients (Android, legacy browsers, embedded systems) may not have cached. Validate that certificate chains are complete and correctly ordered. #### Post-incident certificate forensics When a certificate-related incident occurs (misissuance, unexpected revocation, expiry outage), run the affected domains through this actor to capture the full certificate chain, issuer details, and SANs for forensic analysis. #### M\&A due diligence When acquiring a company or integrating a third-party service, batch-check all their public-facing TLS endpoints. Assess their certificate hygiene, identify soon-to-expire certificates that need renewal, and evaluate their overall TLS posture before committing to integration. #### Bug bounty target reconnaissance During bug bounty hunting, check TLS configurations of all identified subdomains. Weak ciphers, outdated TLS versions, or misconfigured certificate chains can reveal attack vectors — including CRIME, BREACH, POODLE, and certificate misissuance vulnerabilities. *** ### FAQ **Q: Can I check internal/hostname-only domains (e.g., myapp.internal)?** Yes, as long as the domain is resolvable from the actor's runtime environment. Private IP ranges and internal DNS names hosted in split-horizon DNS are reachable only if the actor's default DNS can resolve them. For fully internal domains, consider running a dedicated instance. **Q: Does the actor validate certificate revocation (CRL/OCSP)?** The actor retrieves and reports certificate chain information but does not perform real-time OCSP or CRL revocation checks by default. The checks focus on chain completeness, validity dates, and cryptographic configuration. **Q: What does "expiring\_soon" vs "expiring\_critical" mean?** The default thresholds are: certificates expiring within 30 days are marked `expiring_soon`, and those expiring within 7 days are marked `expiring_critical`. These thresholds can be adjusted if needed. **Q: Does the actor support STARTTLS for SMTP/IMAP/POP3?** The current implementation checks standard TLS on port 443. For STARTTLS-based protocols (port 25/587 SMTP, 143 IMAP, 110 POP3), additional configuration is needed in a specialised version. **Q: Can the actor check wildcard certificates?** Yes. Wildcard certificates are fully supported — the SAN list will include `*.example.com` alongside any explicit SANs. The report notes the wildcard coverage. **Q: How are self-signed certificates handled?** Self-signed certificates are detected and marked accordingly. The chain analysis will flag them since they lack a trusted CA path, but the certificate details (subject, validity, key size) are still reported fully. *** ### Related Tools - **Port Scanner** — Identify hosts with open HTTPS ports (443, 8443) to build your certificate audit target list. - **CVE Vulnerability Lookup** — After identifying TLS library versions from banners, check for known TLS-related CVEs. - **CSP Analyzer** — After validating TLS, check Content-Security-Policy headers on the same web applications. - **Tech Version CVE Checker** — Include TLS library versions in your full technology stack CVE audit. *** ### 🔗 More from perryay Explore the full suite of developer tools on the [Apify Store](https://apify.com/perryay): - [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 any domain - [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 *** ### SEO Keywords SSL certificate checker, TLS certificate validation, certificate expiry monitor, SSL audit, TLS security check, certificate chain analysis, SAN checker, cipher suite checker, TLS version check, HTTPS certificate, CA certificate validation, SSL expiry alert, certificate lifecycle management, SSL inspection, TLS configuration audit, public key audit, digital certificate verification # Actor input Schema ## `domain` (type: `string`): Single domain to check (e.g., example.com). Leave empty for batch. ## `domains` (type: `array`): Multiple domains to check (up to 20). Overrides 'domain' if set. ## `port` (type: `integer`): TLS port to connect to ## `checkChain` (type: `boolean`): Perform full certificate chain analysis (requires pyOpenSSL). Premium feature — additional charge applies. ## `timeoutSecs` (type: `integer`): Connection timeout per domain (2-30s) ## Actor input object example ```json { "domains": [ "example.com", "google.com" ], "port": 443, "checkChain": false, "timeoutSecs": 10 } ``` # Actor output Schema ## `results` (type: `string`): Per-domain certificate analysis 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 = { "domains": [ "example.com", "google.com" ] }; // Run the Actor and wait for it to finish const run = await client.actor("perryay/ssl-certificate-checker").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 = { "domains": [ "example.com", "google.com", ] } # Run the Actor and wait for it to finish run = client.actor("perryay/ssl-certificate-checker").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 '{ "domains": [ "example.com", "google.com" ] }' | apify call perryay/ssl-certificate-checker --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=perryay/ssl-certificate-checker", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "SSL Certificate Checker", "description": "Check SSL/TLS certificate details for one or more domains. Retrieves issuer, subject, validity dates, cipher info, and chain analysis.", "version": "1.0", "x-build-id": "9bqH0FtsHXGj6eyPy" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/perryay~ssl-certificate-checker/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-perryay-ssl-certificate-checker", "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~ssl-certificate-checker/runs": { "post": { "operationId": "runs-sync-perryay-ssl-certificate-checker", "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~ssl-certificate-checker/run-sync": { "post": { "operationId": "run-sync-perryay-ssl-certificate-checker", "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": { "domain": { "title": "Domain (single)", "type": "string", "description": "Single domain to check (e.g., example.com). Leave empty for batch." }, "domains": { "title": "Domains (batch)", "type": "array", "description": "Multiple domains to check (up to 20). Overrides 'domain' if set." }, "port": { "title": "Port", "minimum": 1, "maximum": 65535, "type": "integer", "description": "TLS port to connect to", "default": 443 }, "checkChain": { "title": "Analyze Certificate Chain", "type": "boolean", "description": "Perform full certificate chain analysis (requires pyOpenSSL). Premium feature — additional charge applies.", "default": false }, "timeoutSecs": { "title": "Timeout (seconds)", "minimum": 2, "maximum": 30, "type": "integer", "description": "Connection timeout per domain (2-30s)", "default": 10 } } }, "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 } } } } } } } } } } ```