# X / Twitter Scraper Pro — Tweets, Profiles, Followers (`dever/twitter-ultra-scraper`) Actor Extract tweets by search query, user profiles, timelines, followers and following lists from X (Twitter). Pay per result, no monthly fees, no setup required. - **URL**: https://apify.com/dever/twitter-ultra-scraper.md - **Developed by:** [Hamid Touhami](https://apify.com/dever) (community) - **Categories:** Social media, Automation, Developer tools - **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing Pay per usage This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage ## 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 ## X / Twitter Scraper Pro — Tweets, Profiles, Followers **Extract tweets, user profiles, timelines, followers, and following from X (Twitter). Pay only for results, no setup required.** For growth marketers, OSINT analysts, social-media tooling devs, and anyone who needs X data on tap. Six high-demand operations covering search, profile lookup, timelines, and the social graph. The actor handles credential rotation, proxy management, retries, and pagination. You provide X session credentials and tell us what to fetch — we return clean JSON. $0.35 per 1,000 results, flat. No monthly fees. --- ### What you get - 6 high-demand operations (tweet search, tweet details, user profile, user timeline, followers, following) - Bundled residential proxy pool included — no setup required - Automatic credential rotation across your X account pool - Free preview mode to size jobs before paying - Resumable runs with checkpointed cursors every 100 items - Pay only for results — no monthly fees, no idle charges - **$0.35 per 1,000 results, flat** --- ### How it works You provide X session credentials (one or more, as base64-encoded blobs). We handle the rest — proxy rotation, rate-limit cooldowns, anti-bot dodging, response parsing, error retries, dataset persistence. Each result pushed to the dataset costs **$0.00035**. Preview runs (a single page of samples for sizing) are free. --- ### Quick start The simplest possible run — fetch a public profile: **Input:** ```json { "operation": "user.details", "username": "jack", "credentials": ["YOUR_BASE64_CREDENTIAL_HERE"] } ```` **Output (one record in the dataset):** ```json { "id": "12", "userName": "jack", "fullName": "jack", "createdAt": "2006-03-21T20:50:14.000Z", "description": "no state is the best state", "isVerified": true, "followersCount": 7705481, "followingsCount": 3, "statusesCount": 30523, "_scrapedAt": "2026-05-23T18:09:08.717Z", "_operation": "user.details", "_actorRunId": "abc123..." } ``` Cost: $0.00035 (one result). *** ### Operations - `tweet.search` — Search tweets with filters (keywords, users, dates, engagement). **Max 10,000 results.** - `user.details` — Full profile for a username. Single result. - `tweet.details` — Full data for a tweet ID. Single result. - `user.timeline` — Recent timeline including retweets and replies. **Max 200 results.** (For larger pulls, use `tweet.search` with `fromUsers`.) - `user.followers` — Followers of an account. **Max 500 results.** - `user.following` — Accounts followed by a user. **Max 500 results.** #### `tweet.search` — find tweets matching a filter ```json { "operation": "tweet.search", "maxItems": 500, "searchFilter": { "hashtags": ["bitcoin"], "language": "en", "minLikes": 100, "startDate": "2026-01-01T00:00:00Z" } } ``` Returns tweets matching the filter. Paginated. Up to 10,000 per run. #### `tweet.details` — fetch one tweet by ID ```json { "operation": "tweet.details", "tweetId": "1799876543210123456" } ``` Returns a single tweet object. #### `user.details` — fetch a profile by username ```json { "operation": "user.details", "username": "jack" } ``` Returns the profile (also gives you the numeric `id` you'll need for the next three operations). #### `user.timeline` — fetch tweets posted by a user ```json { "operation": "user.timeline", "userId": "12", "maxItems": 200 } ``` Returns the user's tweets, newest first. Paginated. Up to 200 per run. #### `user.followers` — fetch followers of a user ```json { "operation": "user.followers", "userId": "12", "maxItems": 500 } ``` Returns profiles that follow the target. Paginated. Up to 500 per run. #### `user.following` — fetch accounts a user follows ```json { "operation": "user.following", "userId": "12", "maxItems": 500 } ``` Returns profiles that the target follows. Paginated. Up to 500 per run. *** ### What to expect with different request sizes | Operation | Max items per run | Best for | |---|---|---| | `user.details` / `tweet.details` | 1 | Single-item lookups | | `tweet.search` | 10,000 | Large-scale extraction with filters | | `user.timeline` | 200 | Recent activity feed including retweets and replies | | `user.followers` / `user.following` | 500 | Social graph analysis | #### When to use which - **Need many tweets from a specific user?** Use `tweet.search` with `fromUsers: ["username"]`. Scales to 10,000. - **Need a user's most recent activity including retweets?** Use `user.timeline` (up to 200 items). This includes retweets and replies that don't appear in search results. - **Need follower lists?** Use `user.followers` or `user.following` (up to 500 per run). #### Why these caps exist X enforces different reliability limits across its endpoints. Search has the highest ceiling — we extract 10k tweets reliably via filters. Timeline and follower endpoints have stricter X-side limits; we cap conservatively to avoid partial results and ensure every run completes cleanly. Requests above the cap are **rejected before any fetching starts**, with an error explaining the cap and pointing to the right alternative (e.g. "use tweet.search with `fromUsers`"). No credentials burned, no charge incurred — you'll see the limit immediately and can re-submit with a valid `maxItems`. *** ### Pricing | Event | Price per item | Price per 1,000 | | ----------------- | -------------- | --------------- | | `result_returned` | **$0.00035** | **$0.35** | A single flat rate for tweets and profiles alike. **Preview runs are free.** #### Preview before you pay Add `"preview": true` to any operation: ```json { "operation": "user.followers", "userId": "12", "username": "jack", "preview": true } ``` The actor fetches the first page (≤20 items, free), then writes a `PREVIEW_SUMMARY` record: ```json { "operation": "user.followers", "sampleCount": 20, "estimatedTotal": 4218000, "costEstimate": 1476.30, "hasMore": true } ``` Use this to size a job before committing budget. *** ### How we compare | Feature | This actor | other Twitter Scrapers | |---|---|---| | Price per 1k results | **$0.35** | $0.40 | | Search (max items) | 10,000 | unlimited via date chunking | | User timeline (with retweets/replies) | ✓ (up to 200) | ✗ | | Single tweet lookup | ✓ | ✗ | | Followers / Following | ✓ (up to 500) | ✗ | | Bundled residential proxy | ✓ | ✗ | | Auto username → ID resolution | ✓ | n/a | | Free preview mode | ✓ | ✗ | | Min items per query | none | 50 | *** ### Getting credentials This actor authenticates against X using session credentials you provide. The credentials are base64-encoded session blobs that mirror what your browser sends when logged into X. **Recommended method: X Auth Helper Chrome extension** 1. Install the *X Auth Helper* extension from the Chrome Web Store 2. Allow it in incognito mode 3. Open incognito → log into X (use a dedicated account, never your personal one) 4. Click the extension → "Get Key" → copy the base64 string 5. Close the incognito window **without logging out** (logging out invalidates the session) **Alternative: any community credential generator** that produces base64-encoded session blobs in the same format. Repeated programmatic logins can trigger anti-bot challenges, so generate once and reuse. Pass credentials as the `credentials` array in the input. Credentials remain valid for ~1 year. Treat them as secrets equivalent to passwords. *** ### Reliability & Limits X's API behavior can change without notice, and high-volume accounts may have stricter limits than smaller ones. This actor returns data as X serves it — we don't filter or modify results. **What works reliably:** - Single item lookups (`user.details`, `tweet.details`): >99% success - Search with filters (`tweet.search`): up to ~10,000 results per query - User timeline: up to ~200 items per query - User followers / following: up to ~500 items per query **Known limits:** - For high-traffic accounts (1M+ followers), pagination operations may return partial results around 400–500 items due to X's anti-bot heuristics - We recommend testing your queries with a small `maxItems` first before scaling up - Preview mode (`preview: true`) is free and gives you a size estimate before paying **If a run partially fails**, your dataset still contains all items collected before the failure point. You're charged only for items actually returned. **For very large jobs (>1,000 items)**, we recommend splitting into smaller queries by date range or filter (e.g., `startDate: "2024-01-01"` to `endDate: "2024-06-01"` on `tweet.search`) rather than fetching everything in one run. **Hard caps per run:** - `tweet.search`: up to **10,000 items** - `user.timeline`: up to **200 items** - `user.followers` and `user.following`: up to **500 items** - `tweet.details` and `user.details`: single calls, no pagination For larger workloads, chain runs via the `cursor` field — every paginated run writes a `LAST_CURSOR` record you can pass back to resume. *** ### FAQ **Why do I need to provide credentials?** X gates most data behind authentication. Public-only access (no credentials) returns dramatically less data and gets rate-limited within minutes. Authenticated access via session credentials gets you full feeds, follower lists, and timelines. **What if my credentials get flagged?** The actor automatically rotates across your credential pool. If a credential gets rate-limited or banned, it's marked dead or cooling and the actor moves to the next active one. State persists across runs — once a credential is marked dead, it won't be re-tried until you replace it. **How many credentials do I need?** For light use (under 10k results/day), one is fine. For sustained extraction (tens of thousands of results per day), 5–20 is a healthy pool. Each credential roughly handles 500–1000 reads/hour before throttling kicks in. **Can I use my own proxy instead of the bundled one?** Yes. Provide `proxyConfiguration.proxyUrls` with your own residential proxy URL(s). The bundled proxy only kicks in if you don't supply your own. **What's the maximum amount of data per run?** - `tweet.search`: up to 10,000 items per run - `user.timeline`: up to 200 items per run - `user.followers` and `user.following`: up to 500 items per run - `tweet.details` and `user.details`: single result (no pagination) Requests above an operation's cap are rejected before any fetching starts — no credentials or charges burned. For larger workloads, chain runs via the `cursor` field — every paginated run writes a `LAST_CURSOR` record you can pass back to resume. **Why not use Apify's built-in proxy?** X blocks Apify's published IP ranges. We bundle a residential proxy pool that's configured to work against X. If you select `useApifyProxy: true`, the actor will honor your choice but most requests will fail. **Can I scrape all tweets from a user?** For users with more than 200 tweets, use `tweet.search` with `fromUsers: ["username"]` rather than `user.timeline`. Search scales to 10,000 results per run. For accounts with very long histories, split into date ranges using `startDate` and `endDate` in your search filter. **Why is user.timeline capped at 200?** X enforces tight reliability limits on its timeline endpoint. Beyond ~400 items, responses become malformed and runs fail. We cap at 200 to guarantee every timeline run completes cleanly and includes retweets and replies — content that doesn't always appear in search results. Requests above 200 are rejected before any fetching starts (no credentials or charges burned) so you can re-submit with a valid `maxItems` immediately. **Can I cancel a run mid-way without losing progress?** Yes. Cursor is checkpointed every 100 items to `LAST_CURSOR` in the key-value store. Read it, pass it as `cursor` in a new run, and continue. **Is this allowed by X's Terms of Service?** X's TOS restrict programmatic access. This is a known and accepted risk in the data-extraction ecosystem. Use dedicated accounts for credentials, never your personal X account. *** ### Output Results are pushed to the default dataset, one item per record, in the upstream's native shape plus three metadata fields: ```jsonc { // ...all upstream fields (id, userName, fullText, etc.)... "_scrapedAt": "2026-05-22T14:30:00.000Z", "_operation": "tweet.search", "_actorRunId": "abc123..." } ``` Two preconfigured dataset views: **Tweets** (id, created at, author, text, engagement counts) and **Profiles** (id, username, full name, follower counts, verified flag). *** ### Status codes | Status | Meaning | | ------------------------------- | --------------------------------------------------------------- | | `SUCCEEDED` | Run completed normally. | | `FAILED` | Generic failure — check the run log. | | `FAILED-INVALID-INPUT` | Input failed pre-flight validation (e.g. maxItems above cap). | | `FAILED-CREDENTIALS-EXHAUSTED` | All credentials are dead or cooling. Add fresh ones and rerun. | | `FAILED-UPSTREAM-BROKEN` | Upstream changed its internals; an actor patch is needed. | | `FAILED-UNSUPPORTED-OPERATION` | Operation not in v1 scope. See the supported list above. | *** ### Support Issues and questions: open an issue at the actor's GitHub repository (linked from the Apify Store listing). *** ### Changelog **v1.0** — Initial release. Six operations, credential pool rotation, bundled residential proxy, preview mode, pay-per-result pricing. # Actor input Schema ## `operation` (type: `string`): Which X operation to run. Pick the one matching your goal — see README for examples of each. ## `credentials` (type: `array`): Pool of base64-encoded X session credentials, used to authenticate against X. Provide as a JSON array of strings, e.g. \["cred1", "cred2"]. One credential is enough to start; 5–20 are recommended for sustained workloads. See README for how to generate. ## `username` (type: `string`): Required for user.details. Optional for user.timeline / user.followers / user.following — when provided alongside userId, preview mode will compute estimatedTotal and costEstimate. Handle without @. ## `tweetId` (type: `string`): Required for tweet.details. Numeric tweet ID, copied from a tweet URL: x.com//status/. ## `userId` (type: `string`): Required for user.timeline, user.followers, user.following. Numeric X user ID. If you only have a username, run user.details first to resolve it. ## `searchFilter` (type: `object`): Required for tweet.search. Filter object with optional fields: fromUsers, toUsers, mentions, hashtags, includePhrases, excludeWords, optionalWords, language, startDate, endDate, minLikes, minReplies, minRetweets, links, media, replies, top. See README for the full schema. ## `maxItems` (type: `integer`): Maximum number of items to return. Per-operation caps: tweet.search 10,000; user.timeline 200; user.followers/following 500. Requests above an operation's cap are rejected before any fetching begins, with an error explaining the limit and pointing to higher-volume alternatives. Single-item ops (tweet.details, user.details) ignore this. ## `preview` (type: `boolean`): If true, fetch only the first page (≤20 items) and write a PREVIEW\_SUMMARY record with sample items, estimated total, and cost estimate. No charge for preview runs. Use this to size big jobs before committing budget. ## `cursor` (type: `string`): Pagination cursor to resume a previous run. Read it from the LAST\_CURSOR record written by an earlier run. Cursors are short-lived (hours, not days). Leave blank for a fresh run. ## `proxyConfiguration` (type: `object`): By default the actor routes traffic through a bundled residential proxy pool that is configured to work against X. To override, set proxyUrls with your own residential proxy URL(s). Apify's built-in proxy (useApifyProxy: true) will NOT work — X blocks Apify's IP ranges. Leave blank for the default. ## Actor input object example ```json { "operation": "tweet.search", "maxItems": 100, "preview": false } ``` # 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 = {}; // Run the Actor and wait for it to finish const run = await client.actor("dever/twitter-ultra-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 = {} # Run the Actor and wait for it to finish run = client.actor("dever/twitter-ultra-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 '{}' | apify call dever/twitter-ultra-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=dever/twitter-ultra-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "X / Twitter Scraper Pro — Tweets, Profiles, Followers", "description": "Extract tweets by search query, user profiles, timelines, followers and following lists from X (Twitter). Pay per result, no monthly fees, no setup required.", "version": "1.1", "x-build-id": "c7Lq22lukMHhKgz1v" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/dever~twitter-ultra-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-dever-twitter-ultra-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/dever~twitter-ultra-scraper/runs": { "post": { "operationId": "runs-sync-dever-twitter-ultra-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/dever~twitter-ultra-scraper/run-sync": { "post": { "operationId": "run-sync-dever-twitter-ultra-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": [ "operation" ], "properties": { "operation": { "title": "Operation", "enum": [ "tweet.search", "tweet.details", "user.details", "user.timeline", "user.followers", "user.following" ], "type": "string", "description": "Which X operation to run. Pick the one matching your goal — see README for examples of each.", "default": "tweet.search" }, "credentials": { "title": "X session credentials", "type": "array", "description": "Pool of base64-encoded X session credentials, used to authenticate against X. Provide as a JSON array of strings, e.g. [\"cred1\", \"cred2\"]. One credential is enough to start; 5–20 are recommended for sustained workloads. See README for how to generate.", "items": { "type": "string" } }, "username": { "title": "Username", "type": "string", "description": "Required for user.details. Optional for user.timeline / user.followers / user.following — when provided alongside userId, preview mode will compute estimatedTotal and costEstimate. Handle without @." }, "tweetId": { "title": "Tweet ID", "type": "string", "description": "Required for tweet.details. Numeric tweet ID, copied from a tweet URL: x.com//status/." }, "userId": { "title": "User ID", "type": "string", "description": "Required for user.timeline, user.followers, user.following. Numeric X user ID. If you only have a username, run user.details first to resolve it." }, "searchFilter": { "title": "Search filter", "type": "object", "description": "Required for tweet.search. Filter object with optional fields: fromUsers, toUsers, mentions, hashtags, includePhrases, excludeWords, optionalWords, language, startDate, endDate, minLikes, minReplies, minRetweets, links, media, replies, top. See README for the full schema." }, "maxItems": { "title": "Maximum items", "minimum": 1, "maximum": 100000, "type": "integer", "description": "Maximum number of items to return. Per-operation caps: tweet.search 10,000; user.timeline 200; user.followers/following 500. Requests above an operation's cap are rejected before any fetching begins, with an error explaining the limit and pointing to higher-volume alternatives. Single-item ops (tweet.details, user.details) ignore this.", "default": 100 }, "preview": { "title": "Preview mode (free)", "type": "boolean", "description": "If true, fetch only the first page (≤20 items) and write a PREVIEW_SUMMARY record with sample items, estimated total, and cost estimate. No charge for preview runs. Use this to size big jobs before committing budget.", "default": false }, "cursor": { "title": "Resume cursor", "type": "string", "description": "Pagination cursor to resume a previous run. Read it from the LAST_CURSOR record written by an earlier run. Cursors are short-lived (hours, not days). Leave blank for a fresh run." }, "proxyConfiguration": { "title": "Proxy configuration", "type": "object", "description": "By default the actor routes traffic through a bundled residential proxy pool that is configured to work against X. To override, set proxyUrls with your own residential proxy URL(s). Apify's built-in proxy (useApifyProxy: true) will NOT work — X blocks Apify's IP ranges. Leave blank for the default." } } }, "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 } } } } } } } } } } ```