# Google Images Scraper — Full-Res Image URLs & Source Pages (`jurassic_jove/google-images-scraper`) Actor Scrape Google Images at scale. Get real full-resolution image URLs, source pages, dimensions and file sizes — not expiring thumbnails. Filter by usage rights. - **URL**: https://apify.com/jurassic\_jove/google-images-scraper.md - **Developed by:** [Data Runner](https://apify.com/jurassic_jove) (community) - **Categories:** SEO tools, Lead generation, E-commerce - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $2.00 / 1,000 image result delivereds This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. 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 ## Google Images Scraper — Full-Resolution Image URLs & Source Pages **Scrape Google Images at scale and get the real image, not a thumbnail.** This Google Images scraper returns the full-resolution image URL, the page that hosts it, pixel dimensions, format and file size for every result — exported to JSON, CSV or Excel, or pulled straight from the API. Most cheap image scrapers hand you `encrypted-tbn0.gstatic.com/...` — Google's cached thumbnail. Those are small, stripped of metadata, and they expire. This Actor resolves the **original file on the publisher's own server** plus the **source page URL**, so the data is still useful next month. --- ### What this Google Images scraper extracts | Field | Description | |---|---| | `imageUrl` | **Full-resolution image URL** on the hosting site — not a Google thumbnail | | `sourceUrl` | The web page that publishes the image | | `sourceDomain` | Clean domain of the source page (`example.com`) | | `title` | Image / page title as indexed by Google | | `width`, `height` | True pixel dimensions of the full-resolution file | | `imageFormat` | `jpg`, `png`, `webp`, `gif`, `svg`, … | | `fileSizeLabel` | File size Google reports, e.g. `418KB` | | `dominantColor` | Dominant colour as `rgb(r,g,b)` | | `thumbnailUrl` | Google's cached preview, for quick rendering | | `usageRightsHint` | Which licence filter the search ran under | | `position` | Rank within the query's results | | `contact` | Emails & socials for the source domain (optional add-on) | | `query`, `scrapedAt` | Provenance for every row | #### Sample output ```json { "query": "modern kitchen cabinets tampa", "position": 7, "imageUrl": "https://example-cabinets.com/img/shaker-full.jpg", "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ABC123", "title": "Modern Shaker Cabinets — Tampa Showroom", "sourceUrl": "https://example-cabinets.com/gallery/shaker", "sourceDomain": "example-cabinets.com", "width": 1877, "height": 2560, "imageFormat": "jpg", "fileSizeLabel": "418KB", "dominantColor": "rgb(136,110,104)", "usageRightsHint": "unknown", "contact": null, "scrapedAt": "2026-07-19T12:00:00.000Z" } ```` *** ### How to scrape Google Images 1. Add one or more **search queries** — Google operators work: `site:`, `"exact phrase"`, `-exclude`. 2. Set **max results per query** (up to 100). 3. Optionally filter by **usage rights**, **image size**, **image type**, **country** and **language**. 4. Select **Residential proxies** (required — see below). 5. Run, then export as JSON, CSV, Excel or read the dataset from the API. #### Input example ```json { "queries": ["modern kitchen cabinets tampa", "site:houzz.com shaker kitchen"], "maxResultsPerQuery": 100, "imageSize": "large", "usageRights": "creativeCommons", "country": "us", "language": "en", "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] } } ``` *** ### Search filters | Filter | Options | Google parameter | |---|---|---| | Image type | photo · clip art · line drawing · GIF | `tbs=itp:` | | Image size | large · medium · icon | `tbs=isz:` | | Usage rights | Creative Commons · commercial & other | `tbs=il:` | | SafeSearch | off · moderate · strict | `safe=` | | Country | any two-letter code | `gl=` | | Language | any two-letter code | `hl=` | *** ### Use cases - **Competitive & market research** — see which brands' images rank for your commercial keywords. - **Design and moodboard sourcing** — bulk-collect reference imagery with real dimensions, so you know what is print-usable before downloading. - **Creative Commons image discovery** — filter to CC licences to find imagery you can evaluate for reuse. - **E-commerce catalogue enrichment** — find high-resolution product photography and where it is published. - **Brand monitoring** — track where your product images are being republished, by domain. - **Lead generation** — turn "who ranks for this visual query" into a contact list with the optional enrichment below. - **Dataset building** — assemble labelled image URL sets for computer-vision work. *** ### Turn image results into leads (optional add-on) Set `resolveContacts: true` and every image's **source domain** is looked up for public contact details — emails and social profiles — and attached to the row. That converts a plain image search into a prospecting motion: *"find businesses whose photos rank for `modern kitchen cabinets tampa`, then get their contact details."* The businesses ranking in Google Images for your commercial keywords are, by definition, active in your market and investing in visual content. Billing is honest here: you are charged **only when a contact is actually found**, never per attempt, and never twice for the same domain in one run. *** ### Pricing Pay per event — you pay for results, not runtime. | Event | Price | Charged when | |---|---|---| | Image result delivered | **$0.002** | Each image pushed to the dataset ($2.00 per 1,000) | | Source-domain contact resolved | **$0.005** | Only when a contact is genuinely found ($5.00 per 1,000) | | Actor start | $0.00005 | Once per run | Blocked queries, duplicates and failed extractions are **never** charged. If you set a charge limit, the Actor stops working the moment it is reached rather than burning compute it cannot bill. **Budgeting for contact enrichment.** Image results are far less domain-concentrated than people expect: a measured sample of 100 images spanned **83 distinct source domains**. Since contacts are billed per domain, enabling `resolveContacts` roughly **doubles to triples** the cost of a run rather than adding a rounding error. For 1,000 images expect about $2.00 without enrichment and $4–6 with it. Enable it when you want the leads, not by default. *** ### Requirements & limits — read before your first run **Google Images is aggressively anti-bot, and proxy quality decides your success rate.** Here is exactly what was measured during development, including what did *not* work: | Setup | Measured result | |---|---| | No proxy (direct) | Blocked on the **first** request, every time | | Datacenter proxy, 1 query | Succeeded once — 100 results extracted | | Datacenter proxy, 3–5 queries | **100% blocked**, at both `maxConcurrency` 1 and 4 | | Residential proxy (small/exhausted pool) | **Also blocked** — traffic reached Google, Google returned interstitials | Two things follow from this, and both matter more than any marketing claim: **Lowering concurrency does not rescue datacenter IPs.** A datacenter run at `maxConcurrency: 1` was blocked exactly as completely as one at 4. Google flags the IP range, not the request rate. The schema defaults to `RESIDENTIAL` for this reason. **Residential is necessary, but it was not proven sufficient.** In testing, a residential run still came back blocked: the traffic genuinely reached Google (96 connections to `www.google.com`), but the responses averaged ~23 KB — the size of a CAPTCHA interstitial, not the ~1.3 MB of a real results page. That test ran on a minimal residential pool, and a well-provisioned pool is very likely to behave better — but "very likely" is not "measured", so it is not claimed here as fact. > **Start with one query before you commit to a large run.** Blocked queries cost you nothing, so a single-query test tells you your real success rate on your plan and proxy pool for free. Scale up only once you see results coming back. If Apify Proxy itself rejects the request (common when the selected proxy group is not included in your plan), the run reports `proxy-error` rather than `blocked` — a different problem with a different fix, so the summary keeps them apart. **Roughly 100 results per query is the real ceiling.** Google embeds complete full-resolution data for about the first 100 organic results of a search. Tiles that lazy-load beyond that point carry only a thumbnail and a link — the full-resolution URL genuinely is not on the page, and the legacy pagination parameters no longer return results. Rather than pad the output with thumbnail-only rows, this Actor caps at 100 and tells you in the log. **To go deeper, split one broad query into several narrower ones** (by city, material, style, `site:` domain) — that also produces better-targeted data. **Never crashes on a block.** A blocked query rotates to a fresh proxy session and retries; if it still fails, it is recorded in the run summary and the remaining queries continue. You always get partial results plus a per-query breakdown of what happened. *** ### Copyright & responsible use This Actor returns **publicly available search metadata**: URLs, titles, dimensions and domains. It does not download or redistribute image files by default. `downloadImages` is off by default and stores copies in your own key-value store when enabled. **Indexed in Google Images does not mean free to reuse.** The `usageRightsHint` field reports which licence *filter the search ran under* — it is never a claim about a specific image's licence, because Google does not expose one. Always verify the licence on the source page before reusing an image. *** ### FAQ **Does this return the real image or a Google thumbnail?** The real, full-resolution file hosted on the publisher's own server. The Google thumbnail is included separately as `thumbnailUrl` for previewing. **Why do I only get ~100 images per query?** That is Google's limit for full-resolution data, not the Actor's. Split broad queries into narrower ones to collect more. **Do I need proxies?** Yes, and they need to be good ones. Direct traffic is blocked on the first request, and datacenter IPs are blocked across the whole range no matter how slowly you run. Residential is the right choice, though a thin residential pool was also blocked in testing — see the measured table above. **My run says `proxy-error` — what does that mean?** Apify Proxy rejected the request (HTTP 429/403) before it ever reached Google, almost always because the selected proxy group is not included in your plan. This is reported separately from `blocked` precisely so you do not go hunting for an anti-bot problem you do not have. **Every query came back `blocked`. What now?** Google served an anti-bot interstitial. Blocked queries are never charged, so this costs you nothing but time. Check that you are on residential proxies with a healthy pool, then retry a single query. If one query works and five do not, slow down by lowering `maxConcurrency`. **How do I know it will work before I spend anything?** Run one query. Blocked queries are free, so a single-query test measures your actual success rate at zero cost before you scale up. **Can I search a specific website's images?** Yes. Use Google's `site:` operator, e.g. `site:example.com kitchen`. **Can I find images I am allowed to reuse?** Set `usageRights` to `creativeCommons` or `commercial` to filter the search. Always confirm the licence on the source page before reuse. **What happens if Google blocks a query?** The session rotates to a new proxy IP and retries. If it keeps failing, that query is marked blocked in the summary and the run continues — you keep everything else, and you are not charged for the blocked query. **Can I get emails for the sites hosting these images?** Yes — enable `resolveContacts`. You are billed only for contacts actually found. **What export formats are supported?** JSON, CSV, Excel, XML and HTML table, plus the Apify API and any of its client libraries. **Can I schedule this to run automatically?** Yes — use Apify Schedules to run it hourly, daily or weekly, and monitor how visual search results shift over time. *** ### Build a full pipeline with the Data Runner suite This Actor is one stage of a lead-generation pipeline. Chain it with its siblings: | Actor | What it does | Chain it | |---|---|---| | **[Google Maps Lead Generator](https://apify.com/jurassic_jove/google-maps-lead-generator)** | Local businesses with phone, address, rating & website | Start here for a geographic market | | **Google Images Scraper** *(this Actor)* | Who ranks visually for your keywords, and on which domains | Find the players investing in visual content | | **[Website Email Extractor](https://apify.com/jurassic_jove/website-email-extractor)** | Emails & socials from any list of domains | Feed it the `sourceDomain` column | **Typical flow:** run this Actor on your commercial keywords → export the `sourceDomain` column → feed it into Website Email Extractor → get a contact list of businesses that are already competing for visual attention in your market. Browse the full suite at **[apify.com/jurassic\_jove](https://apify.com/jurassic_jove)**. *** ### Support Found a bug, or has Google changed its result format? Open an issue on the Actor's Issues tab — payload-format changes are treated as priority fixes. # Actor input Schema ## `queries` (type: `array`): One Google Images search per line. Supports Google operators: use site:example.com to restrict to a domain, "quoted phrases" for exact matches, and -word to exclude. Each query returns up to 100 images. ## `maxResultsPerQuery` (type: `integer`): How many images to return for each query. Google embeds full-resolution data for roughly the first 100 organic results per search — values above 100 are capped. To go deeper, split one broad query into several narrower ones. ## `safeSearch` (type: `string`): Filter explicit results. 'moderate' uses Google's default behaviour. ## `imageType` (type: `string`): Restrict to a kind of image. Maps to Google's Type filter. ## `imageSize` (type: `string`): Restrict by image dimensions. Maps to Google's Size filter. ## `usageRights` (type: `string`): Filter by the licence Google has indexed. Useful for finding reusable imagery. Note: this filters the SEARCH — always verify the licence on the source page before reusing an image. ## `country` (type: `string`): Two-letter country code for localised results, e.g. us, gb, de, es, mx. ## `language` (type: `string`): Two-letter interface language code, e.g. en, es, de, fr. ## `resolveContacts` (type: `boolean`): Turn image results into leads: for each image's source domain, look up public emails and social profiles. Billed per resolved contact ($0.005), never per attempt. Note that image results are spread thinly across domains — about 83 distinct domains per 100 images — so this typically doubles or triples the cost of a run, and adds runtime. ## `downloadImages` (type: `boolean`): Off by default: this Actor returns URLs and metadata, it does not redistribute image files. Turning this on stores copies in your key-value store — you are responsible for holding the rights to copy and reuse them. ## `proxyConfiguration` (type: `object`): RESIDENTIAL proxies are required. Google blocks datacenter and unproxied traffic to Images almost immediately, and the run will return blocked queries instead of results. ## `maxConcurrency` (type: `integer`): Queries scraped in parallel. Higher is faster but raises the block rate. Leave at 4 unless you have a large residential proxy pool. ## Actor input object example ```json { "queries": [ "modern kitchen cabinets tampa" ], "maxResultsPerQuery": 100, "safeSearch": "moderate", "imageType": "all", "imageSize": "all", "usageRights": "all", "country": "us", "language": "en", "resolveContacts": false, "downloadImages": false, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] }, "maxConcurrency": 4 } ``` # 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 = { "queries": [ "modern kitchen cabinets", "scandinavian living room" ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }; // Run the Actor and wait for it to finish const run = await client.actor("jurassic_jove/google-images-scraper").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 = { "queries": [ "modern kitchen cabinets", "scandinavian living room", ], "proxyConfiguration": { "useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], }, } # Run the Actor and wait for it to finish run = client.actor("jurassic_jove/google-images-scraper").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 '{ "queries": [ "modern kitchen cabinets", "scandinavian living room" ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }' | apify call jurassic_jove/google-images-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=jurassic_jove/google-images-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Google Images Scraper — Full-Res Image URLs & Source Pages", "description": "Scrape Google Images at scale. Get real full-resolution image URLs, source pages, dimensions and file sizes — not expiring thumbnails. Filter by usage rights.", "version": "0.1", "x-build-id": "dnBZnrofeL4X683Qm" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/jurassic_jove~google-images-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-jurassic_jove-google-images-scraper", "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/jurassic_jove~google-images-scraper/runs": { "post": { "operationId": "runs-sync-jurassic_jove-google-images-scraper", "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/jurassic_jove~google-images-scraper/run-sync": { "post": { "operationId": "run-sync-jurassic_jove-google-images-scraper", "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": [ "queries" ], "properties": { "queries": { "title": "Search queries", "type": "array", "description": "One Google Images search per line. Supports Google operators: use site:example.com to restrict to a domain, \"quoted phrases\" for exact matches, and -word to exclude. Each query returns up to 100 images.", "items": { "type": "string" } }, "maxResultsPerQuery": { "title": "Max results per query", "minimum": 1, "maximum": 100, "type": "integer", "description": "How many images to return for each query. Google embeds full-resolution data for roughly the first 100 organic results per search — values above 100 are capped. To go deeper, split one broad query into several narrower ones.", "default": 100 }, "safeSearch": { "title": "SafeSearch", "enum": [ "off", "moderate", "strict" ], "type": "string", "description": "Filter explicit results. 'moderate' uses Google's default behaviour.", "default": "moderate" }, "imageType": { "title": "Image type", "enum": [ "all", "photo", "clipart", "lineart", "gif" ], "type": "string", "description": "Restrict to a kind of image. Maps to Google's Type filter.", "default": "all" }, "imageSize": { "title": "Image size", "enum": [ "all", "large", "medium", "icon" ], "type": "string", "description": "Restrict by image dimensions. Maps to Google's Size filter.", "default": "all" }, "usageRights": { "title": "Usage rights", "enum": [ "all", "creativeCommons", "commercial" ], "type": "string", "description": "Filter by the licence Google has indexed. Useful for finding reusable imagery. Note: this filters the SEARCH — always verify the licence on the source page before reusing an image.", "default": "all" }, "country": { "title": "Country (gl)", "type": "string", "description": "Two-letter country code for localised results, e.g. us, gb, de, es, mx.", "default": "us" }, "language": { "title": "Language (hl)", "type": "string", "description": "Two-letter interface language code, e.g. en, es, de, fr.", "default": "en" }, "resolveContacts": { "title": "Resolve source-domain contacts (paid add-on)", "type": "boolean", "description": "Turn image results into leads: for each image's source domain, look up public emails and social profiles. Billed per resolved contact ($0.005), never per attempt. Note that image results are spread thinly across domains — about 83 distinct domains per 100 images — so this typically doubles or triples the cost of a run, and adds runtime.", "default": false }, "downloadImages": { "title": "Download image files to key-value store", "type": "boolean", "description": "Off by default: this Actor returns URLs and metadata, it does not redistribute image files. Turning this on stores copies in your key-value store — you are responsible for holding the rights to copy and reuse them.", "default": false }, "proxyConfiguration": { "title": "Proxy configuration", "type": "object", "description": "RESIDENTIAL proxies are required. Google blocks datacenter and unproxied traffic to Images almost immediately, and the run will return blocked queries instead of results.", "default": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }, "maxConcurrency": { "title": "Max concurrency", "minimum": 1, "maximum": 10, "type": "integer", "description": "Queries scraped in parallel. Higher is faster but raises the block rate. Leave at 4 unless you have a large residential proxy pool.", "default": 4 } } }, "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 } } } } } } } } } } ```