# Google Lens OCR API — Image to Text, Batch OCR & PDF (`crawloop/google-lens-ocr-api`) Actor OCR API powered by Google Lens: image to text, batch OCR up to 50 URLs, PDF pages, base64 input, word/line bounding boxes, translation. Standby REST API or dataset batch mode. Pay per successful OCR. Receipt & document scanning. - **URL**: https://apify.com/crawloop/google-lens-ocr-api.md - **Developed by:** [Andrej Kiva](https://apify.com/crawloop) (community) - **Categories:** Developer tools, Automation, Other - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $2.99 / 1,000 ocr images 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## Google Lens OCR API — Image to Text, Batch OCR, PDF & Receipt Scanning > **Disclaimer:** This is an unofficial integration developed independently. It is not affiliated with, sponsored by, or endorsed by Google LLC or any of its subsidiaries. > > **Google Lens** and related names are trademarks of Google LLC. OCR is performed on images supplied by the user via the same public Lens endpoint used by the Chrome browser. > > This Actor is provided **for informational, automation, and document-processing purposes only**. You are solely responsible for ensuring you have the rights to process submitted images and for complying with applicable data protection regulations (GDPR, CCPA, and similar laws). Turn **images and PDFs into structured text** with a production-ready OCR API on Apify. Extract plain text, line-level layout, word-level **bounding boxes**, and optional translation — from a single photo, a batch of up to **50 URLs**, or a **base64-encoded** file without hosting it publicly. Built for developers and automation teams who need reliable **image-to-text**, **receipt OCR**, **invoice scanning**, **document digitization**, and **PDF page extraction** without running headless browsers. Two execution modes: **Standby REST API** (persistent HTTP server, low cold-start latency) and **batch Actor runs** (dataset output for pipelines and schedules). **Best for:** receipt and invoice OCR pipelines, scanned document extraction, multilingual text capture, n8n/Make/Zapier workflows, RPA bots, catalog digitization, and bulk image-to-text export as JSON or CSV. ### When to use this Actor - **Receipt & invoice OCR** — Pull line items, totals, and dates from photos of paper receipts, bills, and shipping labels. - **Batch image-to-text** — Process up to 50 image URLs in one run with parallel workers; ideal for nightly document folders. - **PDF text extraction** — Pass a PDF URL; each rendered page is OCR'd separately (configurable `maxPdfPages`, 1 page = 1 billable OCR event). - **Layout-aware extraction** — Return normalized and pixel **bounding boxes** at word, line, or paragraph level for downstream parsing or UI overlays. - **Private images via base64** — OCR local files without uploading them to a public CDN first. - **Translation workflows** — Extract text and optionally translate output with the `translateTo` ISO 639-1 language code. - **Low-latency API integrations** — Standby mode exposes `GET /ocr`, `POST /ocr`, and `GET /health` for direct HTTP calls from your app or automation tool. ### When not to use this Actor - **Guaranteed handwriting accuracy** — Printed text and clear scans work best; faint, historical, or heavily cursive handwriting may return empty results. - **Scanned PDFs with embedded text layers** — This Actor OCRs page images; native digital PDFs with selectable text may be better handled by a dedicated PDF text parser. - **Real-time video OCR** — Designed for static images and PDF pages, not live camera streams. - **Authenticated private portals** — Only processes URLs and files you can supply directly; no login or session management for gated sites. ### OCR Pipeline ```` Input sources Processing Output ──────────────────── ───────────────────── ────────────────────── imageUrl (single) ──► Google Lens OCR engine ──► fullText imageUrls (batch) ──► + optional translation ──► lines / words imageBase64 ──► + PDF page rendering ──► bounding boxes PDF URL ──► parallel workers ──► dataset or JSON API ```` ### Key Features - **Dual execution modes** — Standby REST API for integrations; batch mode writes structured rows to the Apify dataset. - **Batch up to 50 images** — Parallel processing with configurable concurrency for one-off jobs and scheduled pipelines. - **PDF support** — JPEG, PNG, WebP, BMP, TIFF, HEIC, GIF, and multi-page PDF documents. - **Four output detail levels** — `full`, `lines`, `words`, or `text_only` to balance richness vs payload size. - **Bounding boxes** — Normalized center/width/height plus pixel coordinates for words, lines, and paragraphs. - **Language & region hints** — ISO 639-1 language and ISO 3166-1 region codes improve accuracy for locale-specific formats. - **Base64 input** — Raw base64 or `data:image/...;base64,...` data URIs supported in batch and Standby POST requests. - **Pay per successful OCR** — Charged only when text is extracted successfully; failed or empty results are not billed. - **Lightweight HTTP stack** — No headless browser; uses `curl_cffi` with residential proxy rotation for stable production runs. ### Pricing | Plan | Price per 1,000 OCRs | |---|---| | Free | $2.99 | | Starter | $2.49 | | Scale | $1.99 | | Business | $1.49 | **5 free trial runs** — no credit card required. Failed OCRs (non-empty `error` field or no extracted text) are **not charged**. --- ### How to Use #### Option 1: REST API (Standby Mode) Best for developers, microservices, and automation platforms. Enable Standby when starting the Actor; use the Standby URL shown in the Apify Console. **Authentication:** Apify API token as `Authorization: Bearer YOUR_TOKEN` or `token=YOUR_TOKEN` query parameter. ##### OCR an image by URL (GET) ```bash curl "{STANDBY_ACTOR_URL}/ocr?imageUrl=YOUR_IMAGE_URL" \ -H "Authorization: Bearer YOUR_TOKEN" ```` ##### OCR a local image via base64 (POST) ```bash BASE64=$(base64 -i photo.jpg) curl -X POST "{STANDBY_ACTOR_URL}/ocr" \ -H "Authorization: Bearer YOUR_TOKEN" \ -H "Content-Type: application/json" \ -d "{\"imageBase64\": \"$BASE64\", \"outputDetail\": \"lines\"}" ``` ##### Batch OCR — multiple URLs (POST) ```bash curl -X POST "{STANDBY_ACTOR_URL}/ocr" \ -H "Authorization: Bearer YOUR_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "imageUrls": ["IMAGE_URL_1", "IMAGE_URL_2", "IMAGE_URL_3"], "outputDetail": "lines", "language": "de" }' ``` ##### Python (requests) ```python import base64 import requests TOKEN = "your_apify_token" BASE = "{STANDBY_ACTOR_URL}" # from Apify Console → Standby HEADERS = {"Authorization": f"Bearer {TOKEN}"} ## From URL resp = requests.get(f"{BASE}/ocr", headers=HEADERS, params={ "imageUrl": "YOUR_IMAGE_URL", "outputDetail": "lines", "language": "en", }) print(resp.json()["fullText"]) ## From base64 file with open("receipt.jpg", "rb") as f: img_b64 = base64.b64encode(f.read()).decode() resp = requests.post(f"{BASE}/ocr", headers=HEADERS, json={ "imageBase64": img_b64, "outputDetail": "full", }) for line in resp.json()["lines"]: print(line["text"]) ``` ##### n8n / Make / Zapier Add an HTTP Request step targeting `{STANDBY_ACTOR_URL}/ocr`. Set the `Authorization: Bearer YOUR_TOKEN` header. Pass `imageUrl` as a query parameter (GET) or in the JSON body (POST). ##### Health check ```bash curl "{STANDBY_ACTOR_URL}/health" ``` *** #### Option 2: Batch Processing (Actor Input) Best for one-off jobs, scheduled OCR pipelines, and processing entire document collections. Results are written to the default dataset. ##### Minimal input — single image ```json { "imageUrl": "YOUR_IMAGE_URL" } ``` ##### Batch input — up to 50 images ```json { "imageUrls": [ "IMAGE_URL_1", "IMAGE_URL_2" ], "outputDetail": "lines", "language": "en" } ``` ##### PDF input ```json { "imageUrl": "YOUR_PDF_URL", "maxPdfPages": 10, "outputDetail": "text_only" } ``` ##### Python (Apify Client) ```python from apify_client import ApifyClient client = ApifyClient("your_token") run = client.actor("crawloop/google-lens-ocr-api").call(run_input={ "imageUrls": [ "IMAGE_URL_1", "IMAGE_URL_2", ], "outputDetail": "lines", "language": "en", }) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(f"URL: {item['imageUrl']}") print(f"Text: {item['fullText']}") for line in item.get("lines", []): print(f" [{line['text']}]") ``` ##### JavaScript (Apify Client) ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'your_token' }); const run = await client.actor('crawloop/google-lens-ocr-api').call({ imageUrls: ['IMAGE_URL_1', 'IMAGE_URL_2'], outputDetail: 'lines', }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); for (const item of items) { console.log(`${item.imageUrl}: ${item.fullText}`); } ``` *** ### Input Parameters | Parameter | Type | Default | Description | | :--- | :--- | :--- | :--- | | `imageUrl` | string | — | URL of a single image or PDF document. | | `imageUrls` | array | — | List of image URLs to process in parallel (max 50 per run). | | `imageBase64` | string | — | Base64-encoded image (raw or `data:image/...;base64,...` URI). | | `outputDetail` | string | `full` | `full` / `lines` / `words` / `text_only` — controls structural detail in the response. | | `language` | string | `en` | ISO 639-1 language hint (`en`, `de`, `fr`, `ja`, `ru`, …). | | `region` | string | `US` | ISO 3166-1 region hint for locale-specific formats (addresses, phone numbers). | | `translateTo` | string | — | Optional ISO 639-1 code to translate extracted text. | | `maxPdfPages` | integer | `5` | Maximum PDF pages to render and OCR per document (1–50). | | `proxyConfiguration` | object | Apify proxy | Proxy settings; residential proxies recommended at scale. | #### Output Detail Levels | Level | What's included | |---|---| | `full` | paragraphs → lines → words, all with bounding boxes | | `lines` | line text + bounding boxes (no word-level data) | | `words` | lines with individual word bounding boxes | | `text_only` | plain text only, no coordinates | *** ### Output Format Each successfully processed image produces one dataset item (or one JSON object in Standby mode): ```json { "imageUrl": "YOUR_IMAGE_URL", "language": "en", "fullText": "Invoice #12345\nDate: 2024-01-15\nTotal: $499.00", "processingMs": 380, "error": null, "lines": [ { "text": "Invoice #12345", "boundingBox": { "centerX": 0.445, "centerY": 0.107, "width": 0.851, "height": 0.115, "pixelCoords": { "x": 30, "y": 33, "width": 1265, "height": 77 } }, "words": [ { "text": "Invoice", "boundingBox": { "centerX": 0.12, "centerY": 0.107 } }, { "text": "#12345", "boundingBox": { "centerX": 0.35, "centerY": 0.107 } } ] } ], "paragraphs": [] } ``` #### PDF output Each PDF page is a separate row with an additional `page` field: ```json { "imageUrl": "YOUR_PDF_URL", "page": 1, "language": "en", "fullText": "...", "processingMs": 1200, "error": null } ``` #### Error output Failed images return an `error` string instead of text. These rows are **not billed**: ```json { "imageUrl": "YOUR_IMAGE_URL", "fullText": "", "error": "OCR timeout after 3 attempts", "processingMs": 90000 } ``` *** ### Supported Image Formats JPEG, PNG, WebP, BMP, TIFF, HEIC, GIF, **PDF** *** ### FAQ **How accurate is the OCR?**\ Uses the same OCR engine as Google Lens in Chrome — excellent for printed text, signs, screenshots, and clear scans. Handwriting quality depends on contrast and legibility. **How many images can I process at once?**\ Up to 50 URLs per batch run. In Standby mode, pass an array of URLs in a single POST `/ocr` request. **What about PDFs?**\ Provide a PDF URL and set `maxPdfPages`. Each page is rendered at 150 DPI and OCR'd separately. One page equals one `ocr-image` billing event. **Can I use base64 images?**\ Yes — in both batch mode and Standby POST requests. Supports raw base64 and `data:image/...;base64,...` format. **Is there a rate limit?**\ No hard platform rate limit. Standby mode handles concurrent requests with thread-safe sessions and proxy rotation. **What if an image fails?**\ The response includes an `error` field. Failed or empty OCR results are not charged under pay-per-event pricing. **What languages are supported?**\ Detection is automatic. Set `language` to improve accuracy for a specific locale. Use `translateTo` to return translated text. **How long does processing take?**\ Simple images often complete in seconds. Complex scans, dense documents, or heavy parallel load may take longer; retries run automatically on transient timeouts. **Which mode should I choose?**\ Use **Standby** for API integrations and low-latency calls. Use **batch mode** for scheduled jobs, large exports, and Apify dataset/CSV workflows. *** ### Legal Compliance This Actor processes images and PDFs supplied by the user. Users must ensure they have the legal right to process submitted content and must comply with applicable privacy and data-protection laws in their jurisdiction. # Actor input Schema ## `imageUrl` (type: `string`): URL of a single image to extract text from. Supported formats: JPEG, PNG, WebP, BMP, TIFF, HEIC, GIF, PDF. ## `imageUrls` (type: `array`): List of image URLs to process in parallel. Up to 50 per run. ## `imageBase64` (type: `string`): Base64-encoded image. Supports raw base64 or data URI format (data:image/png;base64,...). Use when you don't have a public URL. ## `outputDetail` (type: `string`): Controls how much structural data is returned. **full** — paragraphs, lines, words + bounding boxes **lines** — line text + bounding boxes **words** — word-level bounding boxes **text\_only** — plain text, no coordinates ## `language` (type: `string`): Language hint for the OCR engine. Examples: en, de, fr, es, ja, zh, ar, ko, ru. Improves accuracy for the specified language without limiting detection of others. ## `region` (type: `string`): Country code used as a regional hint. Improves accuracy for region-specific formats like addresses and phone numbers. ## `translateTo` (type: `string`): Translate extracted text to this language. Leave empty to return original text. Examples: en, de, es, fr, ja. ## `maxPdfPages` (type: `integer`): When processing a PDF URL, how many pages to extract. Each page counts as one OCR event. ## `proxyConfiguration` (type: `object`): Proxy settings. Residential proxies recommended for large-scale usage. ## Actor input object example ```json { "outputDetail": "full", "language": "en", "region": "US", "maxPdfPages": 5, "proxyConfiguration": { "useApifyProxy": true } } ``` # 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 = { "proxyConfiguration": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("crawloop/google-lens-ocr-api").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 = { "proxyConfiguration": { "useApifyProxy": True } } # Run the Actor and wait for it to finish run = client.actor("crawloop/google-lens-ocr-api").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 '{ "proxyConfiguration": { "useApifyProxy": true } }' | apify call crawloop/google-lens-ocr-api --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=crawloop/google-lens-ocr-api", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Google Lens OCR API — Image to Text, Batch OCR & PDF", "description": "OCR API powered by Google Lens: image to text, batch OCR up to 50 URLs, PDF pages, base64 input, word/line bounding boxes, translation. Standby REST API or dataset batch mode. Pay per successful OCR. Receipt & document scanning.", "version": "1.0", "x-build-id": "zPMSzo5ukPa9Djecs" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/crawloop~google-lens-ocr-api/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-crawloop-google-lens-ocr-api", "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/crawloop~google-lens-ocr-api/runs": { "post": { "operationId": "runs-sync-crawloop-google-lens-ocr-api", "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/crawloop~google-lens-ocr-api/run-sync": { "post": { "operationId": "run-sync-crawloop-google-lens-ocr-api", "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": { "imageUrl": { "title": "Image URL", "type": "string", "description": "URL of a single image to extract text from. Supported formats: JPEG, PNG, WebP, BMP, TIFF, HEIC, GIF, PDF." }, "imageUrls": { "title": "Image URLs (batch)", "type": "array", "description": "List of image URLs to process in parallel. Up to 50 per run." }, "imageBase64": { "title": "Image (base64)", "type": "string", "description": "Base64-encoded image. Supports raw base64 or data URI format (data:image/png;base64,...). Use when you don't have a public URL." }, "outputDetail": { "title": "Output detail level", "enum": [ "full", "lines", "words", "text_only" ], "type": "string", "description": "Controls how much structural data is returned.\n\n**full** — paragraphs, lines, words + bounding boxes\n**lines** — line text + bounding boxes\n**words** — word-level bounding boxes\n**text_only** — plain text, no coordinates", "default": "full" }, "language": { "title": "Language hint (ISO 639-1)", "type": "string", "description": "Language hint for the OCR engine. Examples: en, de, fr, es, ja, zh, ar, ko, ru. Improves accuracy for the specified language without limiting detection of others.", "default": "en" }, "region": { "title": "Region hint (ISO 3166-1 alpha-2)", "enum": [ "US", "GB", "DE", "FR", "CA", "AU", "ES", "IT", "BR", "NL", "AR", "AT", "BE", "CH", "CL", "CO", "CZ", "DK", "FI", "GR", "HU", "IE", "IN", "JP", "KR", "MX", "NO", "NZ", "PL", "PT", "RO", "RU", "SE", "SG", "SK", "TR", "UA", "ZA" ], "type": "string", "description": "Country code used as a regional hint. Improves accuracy for region-specific formats like addresses and phone numbers.", "default": "US" }, "translateTo": { "title": "Translate to (ISO 639-1)", "type": "string", "description": "Translate extracted text to this language. Leave empty to return original text. Examples: en, de, es, fr, ja." }, "maxPdfPages": { "title": "Max PDF pages", "minimum": 1, "maximum": 50, "type": "integer", "description": "When processing a PDF URL, how many pages to extract. Each page counts as one OCR event.", "default": 5 }, "proxyConfiguration": { "title": "Proxy configuration", "type": "object", "description": "Proxy settings. Residential proxies recommended for large-scale usage." } } }, "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 } } } } } } } } } } ```