# Website Technology Stack Detector (`perryay/website-tech-stack-detector`) Actor Identify technologies powering any website — CMS, frameworks, analytics, CDN, hosting, payment processors, and JS libraries from HTML and HTTP headers. - **URL**: https://apify.com/perryay/website-tech-stack-detector.md - **Developed by:** [Perry AY](https://apify.com/perryay) (community) - **Categories:** Developer tools, AI - **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 ## Website Technology Stack Detector ### Website Technology Stack Detector **Website Technology Stack Detector** identifies the **full technology stack** powering any website — content management systems, JavaScript frameworks, analytics platforms, CDN providers, hosting services, payment processors, and more — directly from HTML and HTTP response analysis. Covers **30+ technology signatures** across **10 categories** with configurable batch scanning and optional deep audit mode. --- ### What does it do? Every website is built on a combination of technologies — a CMS to manage content, a JavaScript framework for interactivity, an analytics platform to track visitors, a CDN for performance, and a hosting provider to serve it all. The Website Technology Stack Detector extracts this invisible infrastructure by analysing both **HTML content patterns** (script tags, meta elements, CSS classes, DOM structures) and **HTTP response headers** (server headers, cookies, X-Powered-By, set-cookie patterns). The result is a structured, machine-readable report of every technology detected on the target URL, grouped by category and tagged with a confidence level so you know how reliable each detection is. Whether you need to analyse a single site or audit up to 20 URLs in one batch run, the actor returns clean JSON ready for downstream integration, dashboards, or enrichment pipelines. The actor supports three modes: - **Single Analysis** — one URL, one result. - **Batch Mode** — up to 20 URLs in a single run, each independently analysed. - **Full Audit** — extended HTML parsing for deeper detection on complex or heavily customised sites. --- ### Features | # | Feature | Description | |---|---------|-------------| | 1 | **Multi-Vector Detection** | Analyses both HTML content (script tags, meta elements, CSS classes) and HTTP response headers (server headers, cookies, X-Powered-By) | | 2 | **30+ Technology Signatures** | Pre-built detection patterns covering the most widely used web technologies | | 3 | **10 Category Groups** | Technologies are automatically organised into CMS, JavaScript Frameworks, Analytics, CDN/Security, Hosting, E-commerce, Payment Processors, CSS Frameworks, and more | | 4 | **Confidence Scoring** | Each detection is tagged `high`, `medium`, or `low` based on the number and specificity of signature matches | | 5 | **Batch Processing** | Analyse up to 20 URLs in a single actor run with independent per-URL results | | 6 | **Full Audit Mode** | Enable deeper HTML parsing for extended detection coverage on complex or obfuscated sites | | 7 | **Fast Execution** | Typical single-URL analysis completes in seconds; batch runs scale linearly | | 8 | **No False Positives** | Reports only signatures that positively match — no speculative or probabilistic detections | | 9 | **CI/CD Ready** | REST API and ApifyClient SDK enable integration into automated pipelines | | 10 | **MCP Compatible** | Can be called from any MCP-compatible AI agent (Claude, Cursor, Windsurf, etc.) | --- ### Why use this? | Pain Point | How This Actor Solves It | |------------|--------------------------| | Manually inspecting "View Page Source" for every competitor | Automated detection returns a structured report in seconds | | No visibility into what tech your prospects use | Batch scan 20 URLs at once to qualify leads by technology fit | | Security teams lack an accurate technology inventory | Full Audit mode uncovers hidden components for vulnerability mapping | | Sales outreach relies on stale or incomplete tech data | Fresh analysis on demand — no stale spreadsheets | | Integration pipelines need per-URL technology metadata | Clean JSON output with categories, confidence, and counts | | AI agents need context about a website's stack before acting | MCP integration lets agents query the actor directly | --- ### Who is it for? | Persona | What They Use It For | |---------|---------------------| | **Security Engineer** | Mapping technology inventory across owned domains to identify outdated or vulnerable components | | **Sales Development Rep (SDR)** | Qualifying prospects by determining whether their stack includes target technologies (e.g., Shopify stores, Magento sites) | | **Market Researcher** | Analysing technology adoption trends across industries for reports and strategy | | **Product Manager** | Understanding competitor technology choices to inform product roadmap and positioning | | **Web Developer / Architect** | Quick reconnaissance on a site's frontend and backend stack before planning integrations or migrations | | **AI / Automation Engineer** | Feeding website technology data into downstream agents via MCP or API for context-aware workflows | | **Recruiter / Talent Sourcer** | Identifying companies using specific technologies to target candidates and skills demand | --- ### Input Parameters | Field | Type | Default | Description | |-------|------|---------|-------------| | `url` | `string` | — | Website URL to analyse (required for single mode, optional in batch mode) | | `fullAudit` | `boolean` | `false` | Enable extended detection with deeper HTML parsing for maximum accuracy | | `batchMode` | `boolean` | `false` | Enable batch URL analysis (set to `true` and provide `batchData`) | | `batchData` | `array` | `[]` | List of URL strings or objects `{"url": "..."}` for batch analysis (max 20) | #### Example Input JSON **Single analysis:** ```json { "url": "https://example.com" } ```` **Single analysis with full audit:** ```json { "url": "https://example.com", "fullAudit": true } ``` **Batch mode (20 URLs):** ```json { "batchMode": true, "batchData": [ "https://example.com", "https://example.org", {"url": "https://example.net"}, "https://example.edu" ], "fullAudit": false } ``` *** ### Output Format | Field | Type | Description | |-------|------|-------------| | `url` | `string` | The analysed website URL | | `technologies` | `array` | List of detected technology entries | | `technologies[].name` | `string` | Technology name (e.g., "Next.js", "Cloudflare") | | `technologies[].category` | `string` | Technology category (e.g., "JavaScript Framework", "CDN") | | `technologies[].confidence` | `string` | Detection confidence: `high`, `medium`, or `low` | | `tech_count` | `integer` | Total number of technologies detected | | `categories` | `object` | Category-to-count mapping (e.g., `{"CMS": 1, "Hosting": 2}`) | | `error` | `string` | Error message if analysis failed (absent on success) | #### Example Output JSON ```json { "url": "https://www.shopify.com", "technologies": [ { "name": "Shopify", "category": "E-commerce", "confidence": "high" }, { "name": "React", "category": "JavaScript Framework", "confidence": "high" }, { "name": "jQuery", "category": "JavaScript Framework", "confidence": "medium" }, { "name": "Cloudflare", "category": "CDN/Security", "confidence": "high" }, { "name": "Google Analytics", "category": "Analytics", "confidence": "high" }, { "name": "Stripe", "category": "Payment Processor", "confidence": "medium" } ], "tech_count": 6, "categories": { "E-commerce": 1, "JavaScript Framework": 2, "CDN/Security": 1, "Analytics": 1, "Payment Processor": 1 } } ``` *** ### Supported Technologies | Category | Technologies Detected | |----------|-----------------------| | **CMS** | WordPress, Drupal, Joomla, Wix, Squarespace | | **E-commerce** | Shopify, Magento, WooCommerce, BigCommerce | | **JavaScript Frameworks** | React, Next.js, Vue.js, Angular, Svelte, jQuery, Nuxt.js, Gatsby | | **CSS Frameworks** | Tailwind CSS, Bootstrap, Foundation, Bulma | | **Analytics** | Google Analytics, Google Tag Manager, Hotjar, Cloudflare Analytics, HubSpot, Segment, Mixpanel | | **CDN / Security** | Cloudflare, Akamai, Fastly, CloudFront, Imperva | | **Cloud / Hosting** | AWS, Netlify, Vercel, Heroku, DigitalOcean, Azure | | **Payment Processors** | Stripe, PayPal, Square, Braintree | | **Miscellaneous** | Font Awesome, reCAPTCHA, Typekit/Adobe Fonts, Mapbox, YouTube Embedded | *** ### API Usage #### cURL ```bash ## Single analysis curl -X POST "https://api.apify.com/v2/acts/perryay~website-tech-stack-detector/runs?token=YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{"url": "https://example.com"}' ## Batch analysis (20 URLs) curl -X POST "https://api.apify.com/v2/acts/perryay~website-tech-stack-detector/runs?token=YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{"batchMode": true, "batchData": ["https://example.com", "https://example.org"]}' ## Full audit curl -X POST "https://api.apify.com/v2/acts/perryay~website-tech-stack-detector/runs?token=YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{"url": "https://example.com", "fullAudit": true}' ``` #### Python (ApifyClient) ```python from apify_client import ApifyClient ## Initialize the client with your API token client = ApifyClient("YOUR_APIFY_TOKEN") ## Prepare the actor input run_input = { "url": "https://example.com", "fullAudit": False, "batchMode": False, "batchData": [], } ## Run the actor and wait for results run = client.actor("perryay/website-tech-stack-detector").call(run_input=run_input) ## Fetch and print the results for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(f"URL: {item['url']}") print(f"Technologies detected: {item['tech_count']}") for tech in item['technologies']: print(f" - {tech['name']} ({tech['category']}) [{tech['confidence']}]") print(f"Categories: {item['categories']}") print("---") ``` #### Node.js (ApifyClient) ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' }); const input = { url: 'https://example.com', fullAudit: false, batchMode: false, batchData: [], }; const run = await client.actor('perryay/website-tech-stack-detector').call(input); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach(item => { console.log(`URL: ${item.url}`); console.log(`Technologies detected: ${item.tech_count}`); item.technologies.forEach(tech => { console.log(` - ${tech.name} (${tech.category}) [${tech.confidence}]`); }); }); ``` *** ### Use Cases #### 1. Competitive Intelligence Analyse competitor websites to understand their technology choices. Identify which CMS they use, whether they've adopted a particular JavaScript framework, or which CDN powers their performance strategy. Share insights across product, marketing, and engineering teams. #### 2. Sales Prospecting & Lead Qualification Sales teams targeting Shopify merchants, WordPress sites, or React-based web apps can batch-scan prospect URLs and segment leads by technology fit. Focus outreach on high-intent accounts already using complementary tools. #### 3. Security & Vulnerability Assessment Security teams can maintain an accurate technology inventory across owned domains. Detect outdated or deprecated technologies, identify unexpected CDN or hosting changes, and prioritise patching based on the actual software in use. #### 4. Market Research & Trend Analysis Scan a representative sample of websites in a vertical (e.g., top 100 e-commerce sites) and aggregate the results to measure technology adoption rates, framework migration trends, and CDN market share. #### 5. Merger & Acquisition (M\&A) Due Diligence During M\&A tech due diligence, quickly profile the target company's web technology stack to identify integration complexity, technical debt, and dependency risks before the deal closes. #### 6. AI Agent Context Enrichment Equip AI agents with real-time knowledge of a website's technology stack before they generate code, write documentation, or make architectural recommendations. The MCP integration makes this seamless. #### 7. Recruitment & Talent Sourcing Identify companies using specific technologies (e.g., "Next.js + Tailwind + Vercel") to target relevant job openings and candidates with matching skills. #### 8. SEO & Performance Auditing Understanding the underlying framework and CDN helps contextualise page speed scores, Core Web Vitals, and SEO recommendations. Correlate technology choices with performance metrics. #### 9. API & Integration Planning Before building an integration with a third-party site or service, determine which APIs and technologies they use to plan compatibility and authentication requirements. #### 10. Continuous Monitoring Run the actor on a schedule (daily/weekly via Apify Cron or CI pipeline) to track technology stack changes on important domains — detect migrations away from a platform, new CDN deployments, or analytics additions. *** ### FAQ **Q: How does the detection work?** A: The actor combines two analysis vectors: (1) **HTML content analysis** — scanning script tags, meta elements, link tags, CSS classes, and DOM patterns for known signatures; and (2) **HTTP response header analysis** — inspecting server headers, X-Powered-By, Set-Cookie patterns, and other response metadata for technology fingerprints. **Q: How accurate is the detection?** A: Each detection is tagged with a confidence level (`high`, `medium`, or `low`). High confidence means multiple distinct signatures matched the same technology. Medium confidence means a single strong signature matched. Low confidence indicates partial or heuristic matches. We do not report speculative results — every detection has at least one positive signature. **Q: How many URLs can I scan in batch mode?** A: Batch mode supports up to **20 URLs per run**. Each URL is analysed independently with its own result row. If you need to scan more than 20 URLs, split them across multiple runs. **Q: What happens when a website uses custom-built technology?** A: Custom-built or highly bespoke sites will have fewer detections. The actor reports only positive signature matches and will never fabricate a detection. You'll still get results for any standard technologies (hosting, CDN, analytics) that are present. **Q: Does this actor produce false positives?** A: The actor is designed to avoid false positives by requiring positive signature matches. It does not use probabilistic or heuristic models that could guess incorrectly. If a technology is not positively detected, it is simply not included in the output. **Q: What categories of technology can you detect?** A: Ten categories are currently covered: CMS, E-commerce, JavaScript Frameworks, CSS Frameworks, Analytics, CDN/Security, Cloud/Hosting, Payment Processors, and Miscellaneous (icons, fonts, CAPTCHA, maps, embedded media). New categories and signatures are added regularly. **Q: Can I integrate this into my CI/CD pipeline?** A: Yes. The actor has a full REST API and supports the ApifyClient SDK for Python and JavaScript. You can trigger analysis from any CI/CD system (GitHub Actions, GitLab CI, Jenkins) using cURL or the SDK. See the API Usage section above for examples. **Q: Is there rate limiting?** A: Apify platform platform-level rate limits apply. Within a single actor run, URLs are processed sequentially. For high-throughput batch requirements, use multiple parallel actor runs within your Apify account's concurrency limits. **Q: Does the actor support MCP (Model Context Protocol)?** A: Yes. The actor is fully compatible with the Apify MCP Server. See the MCP Integration section below for the configuration block. **Q: Is there a batch processing limit?** A: Batch mode supports up to **20 URLs per run**. Each URL is analysed independently with its own result row. If you need to scan more than 20 URLs, split them across multiple runs. **Q: Can I detect technologies on a page that requires authentication?** A: The actor performs public-facing analysis only — it does not handle login sessions or authenticated pages. For behind-login analysis, you would need to provide pre-authenticated cookies or use a browser-based actor. **Q: How often are the detection signatures updated?** A: The signature database is updated regularly as new technologies emerge and existing platforms update their fingerprints. The actor always uses the latest signatures available at the time of the run — no manual update step required. **Q: What should I do if a technology I need is not in the supported list?** A: The actor's technology signatures are continuously expanded. If you have a specific technology you need detected, please contact the actor maintainer with the website URL and the technology name for consideration in a future update. *** ### Usage & Billing This actor uses Apify's **PAY\_PER\_EVENT** pricing model. You are charged only for successful runs based on the events your usage triggers. #### Charge Events | Event | Trigger | |-------|--------| | `apify-actor-start` | Every run (base) | | `tech-audit` | `fullAudit: true` — detailed technology audit | | `cve-crossref` | `fullAudit: true` — CVE cross-reference (included in audit) | Platform costs (Apify's infrastructure fee) are passed through to the customer. *** ### MCP Integration This actor can be used through the [Apify MCP server](https://docs.apify.com/integrations/mcp). Once connected, your MCP client (Claude Desktop, Cursor, etc.) can discover and run this actor from the Apify Store. #### Quick Start 1. **Install the Apify connector** in your MCP client: - **Claude Desktop**: Search for "Apify" in the connector directory, or use the remote server at `https://mcp.apify.com` - **Other clients**: See the [Apify MCP server docs](https://docs.apify.com/integrations/mcp) for setup instructions 2. **Ask your AI assistant** to detect technology stacks. For example: > "Analyse the technology stack of https://example.com and summarise what CMS, framework, and CDN it uses." #### Claude Desktop Configuration Add the following to your `claude_desktop_config.json`: ```json { "mcpServers": { "apify": { "url": "https://mcp.apify.com" } } } ``` On first connection, your browser opens to sign in to Apify and authorize access. > **Bearer token alternative:** For headless environments, CI/CD pipelines, or clients without browser-based OAuth, you can authenticate directly with your Apify API token: > > ```json > { > "mcpServers": { > "apify": { > "url": "https://mcp.apify.com", > "headers": { > "Authorization": "Bearer YOUR_APIFY_TOKEN" > } > } > } > } > ``` > > Get your API token from [Apify Console](https://console.apify.com) → **API & Integrations** section. *** ### Related Tools - **[SSL Certificate Checker](https://apify.com/perryay/ssl-certificate-checker)** — Validate SSL/TLS certificate chains, expiry dates, and issuer details for domains detected in your tech stack. - **[Domain Intel](https://apify.com/perryay/domain-intel)** — WHOIS lookups, DNS enumeration, and SSL certificate validation — complete domain reconnaissance to complement stack detection. - **[URL Health Checker](https://apify.com/perryay/url-health)** — Monitor URL availability, HTTP status codes, and SSL health across all URLs in your infrastructure. - **[CVE Vulnerability Lookup](https://apify.com/perryay/cve-vulnerability-lookup)** — Cross-reference detected technology versions against known CVEs for proactive vulnerability management. - **[Link Quality Analyzer](https://apify.com/perryay/link-quality-analyzer)** — Deep link health and quality scoring for SEO and content auditing across detected web properties. # Actor input Schema ## `url` (type: `string`): The URL of the website to analyze for technology stack detection ## `fullAudit` (type: `boolean`): Extended detection with deeper HTML parsing and header analysis ## `batchMode` (type: `boolean`): Enable to analyze multiple websites in a single run ## `batchData` (type: `array`): Array of website URLs for batch analysis ## Actor input object example ```json { "url": "https://example.com", "fullAudit": false, "batchMode": false, "batchData": [ { "url": "https://example.com" }, { "url": "https://google.com" } ] } ``` # Actor output Schema ## `results` (type: `string`): Technology detection results in the default dataset — one item per analyzed URL # 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 = { "url": "https://example.com", "batchData": [ { "url": "https://example.com" }, { "url": "https://google.com" } ] }; // Run the Actor and wait for it to finish const run = await client.actor("perryay/website-tech-stack-detector").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 = { "url": "https://example.com", "batchData": [ { "url": "https://example.com" }, { "url": "https://google.com" }, ], } # Run the Actor and wait for it to finish run = client.actor("perryay/website-tech-stack-detector").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 '{ "url": "https://example.com", "batchData": [ { "url": "https://example.com" }, { "url": "https://google.com" } ] }' | apify call perryay/website-tech-stack-detector --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=perryay/website-tech-stack-detector", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Website Technology Stack Detector", "description": "Identify technologies powering any website — CMS, frameworks, analytics, CDN, hosting, payment processors, and JS libraries from HTML and HTTP headers.", "version": "1.0", "x-build-id": "Dyxkat1u9EKHKjTB2" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/perryay~website-tech-stack-detector/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-perryay-website-tech-stack-detector", "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~website-tech-stack-detector/runs": { "post": { "operationId": "runs-sync-perryay-website-tech-stack-detector", "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~website-tech-stack-detector/run-sync": { "post": { "operationId": "run-sync-perryay-website-tech-stack-detector", "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": "Website URL", "type": "string", "description": "The URL of the website to analyze for technology stack detection" }, "fullAudit": { "title": "Full Technology Audit", "type": "boolean", "description": "Extended detection with deeper HTML parsing and header analysis", "default": false }, "batchMode": { "title": "Batch Mode", "type": "boolean", "description": "Enable to analyze multiple websites in a single run", "default": false }, "batchData": { "title": "Batch Website Data", "type": "array", "description": "Array of website URLs for batch analysis" } } }, "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 } } } } } } } } } } ```