# Shopify Store Scraper - Products & Collections Extractor (`xquantify/shopify-store-scraper`) Actor
Extract products, collections & inventory from any Shopify store. Multi-currency support, stock detection, anti-bot bypass. Fast, reliable & easy to use.
- **URL**: https://apify.com/xquantify/shopify-store-scraper.md
- **Developed by:** [xquantify](https://apify.com/xquantify) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 18 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
$9.90 / 1,000 results
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
## Shopify Store Scraper - Products & Collections Extractor
Extract comprehensive product data, collections, and inventory information from any Shopify store. This powerful Apify Actor supports multi-currency pricing, stock status detection, and advanced anti-bot protection bypass.
### 🎉 FREE Tier: 500 Products/Month - No Credit Card Required!
**Pay-Per-Event Pricing:**
- ✅ **500 FREE products** every month
- ✅ **50 FREE collections** every month
- ✅ **$0 monthly rental fee**
- 💰 After free tier: Just $2 per 1,000 products
- 📊 Scale from free to enterprise seamlessly
[See full pricing details →](./PRICING.md)
### Features
#### Core Capabilities
- **Extract All Products**: Scrape complete product catalogs from any Shopify store
- **Collection Scraping**: Fetch all collections with product counts and metadata
- **Single Product Mode**: Extract detailed data from specific product URLs
- **Multi-Currency Support**: Get prices in any currency (USD, EUR, GBP, etc.)
- **Stock Status Detection**: Automatically detect InStock/OutOfStock status for products
- **Variant Support**: Extract all product variants with individual pricing and inventory
- **Image Extraction**: Get all product images in high resolution
- **Anti-Bot Protection**: Advanced techniques to bypass Shopify's gateway restrictions
#### Advanced Features
- **Currency Passthrough**: Automatic currency conversion using Shopify's API
- **Inventory Tracking**: Real-time stock quantities for each variant
- **Pagination Handling**: Automatically handles stores with thousands of products
- **Rate Limiting**: Smart delays and retry logic to avoid blocks
- **Residential Proxies**: Built-in proxy support for restricted stores
- **Comprehensive Data**: Extract titles, descriptions, prices, SKUs, tags, vendors, and more
### Use Cases
- **Price Monitoring**: Track competitor pricing across multiple Shopify stores
- **Market Research**: Analyze product trends and inventory levels
- **Dropshipping**: Find trending products and monitor stock availability
- **Product Database**: Build comprehensive product catalogs
- **Inventory Management**: Monitor stock levels across multiple stores
- **E-commerce Analytics**: Gather data for business intelligence
### Input Configuration
#### Basic Setup
```json
{
"startUrls": [
{ "url": "https://example.myshopify.com" }
],
"mode": "PRODUCTS",
"currency": "USD",
"checkStock": true
}
````
#### Input Parameters
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `startUrls` | Array | Yes | List of Shopify store URLs to scrape |
| `mode` | String | Yes | Scraping mode: `PRODUCTS`, `COLLECTIONS`, `SINGLE_PRODUCT`, or `ALL` |
| `currency` | String | No | ISO currency code (e.g., USD, EUR, GBP) |
| `collectionUrls` | Array | No | Specific collection URLs to scrape products from |
| `productUrls` | Array | No | Specific product URLs (for SINGLE\_PRODUCT mode) |
| `maxProducts` | Integer | No | Maximum number of products to scrape |
| `maxCollections` | Integer | No | Maximum number of collections to scrape |
| `includeVariants` | Boolean | No | Include all product variants (default: true) |
| `includeImages` | Boolean | No | Include product images (default: true) |
| `includeDescription` | Boolean | No | Include full descriptions (default: true) |
| `includeCategories` | Boolean | No | Include categories/collections each product belongs to (default: false) |
| `checkStock` | Boolean | No | Check stock status (default: true) |
| `proxyConfiguration` | Object | No | Proxy settings (recommended: residential proxies) |
### Scraping Modes
#### 1. All Products Mode (`PRODUCTS`)
Extracts all products from the store or specific collections.
```json
{
"startUrls": [{ "url": "https://store.myshopify.com" }],
"mode": "PRODUCTS",
"currency": "USD"
}
```
#### 2. Collections Mode (`COLLECTIONS`)
Extracts only collection information without products.
```json
{
"startUrls": [{ "url": "https://store.myshopify.com" }],
"mode": "COLLECTIONS"
}
```
#### 3. Single Product Mode (`SINGLE_PRODUCT`)
Extracts detailed data for specific products.
```json
{
"startUrls": [{ "url": "https://store.myshopify.com" }],
"mode": "SINGLE_PRODUCT",
"productUrls": [
"https://store.myshopify.com/products/awesome-product"
],
"checkStock": true
}
```
#### 4. Everything Mode (`ALL`)
Extracts both collections and all products.
```json
{
"startUrls": [{ "url": "https://store.myshopify.com" }],
"mode": "ALL",
"currency": "EUR"
}
```
### Output Format
#### Product Data - Complete Field List
All products include the following fields:
**Basic Information:**
- `type`: "product"
- `id`: Unique product ID
- `title`: Product title/name
- `handle`: URL-friendly product handle
- `url`: Full product URL
- `vendor`: Brand/vendor name
- `productType`: Product type/category
- `tags`: Array of product tags
- `createdAt`: Product creation date
- `publishedAt`: Product publish date
- `updatedAt`: Last update date
**Pricing:**
- `price`: Minimum variant price
- `priceMax`: Maximum variant price (if different)
- `compareAtPrice`: Minimum compare-at price (original price)
- `compareAtPriceMax`: Maximum compare-at price (if different)
- `currency`: ISO currency code (USD, EUR, GBP, etc.)
- `onSale`: Boolean indicating if product is on sale
**Availability & Stock:**
- `stockStatus`: "InStock" or "OutOfStock"
- `availableForSale`: Boolean availability flag
- `totalInventory`: Total inventory count (if checkStock enabled)
- `availableVariants`: Number of available variants
- `totalVariants`: Total number of variants
**Taxability:**
- `taxable`: Boolean indicating if any variant is taxable
- `allVariantsTaxable`: Boolean indicating if all variants are taxable
- `taxCodes`: Array of unique tax codes (if available)
**SKUs:**
- `skus`: Array of all unique SKUs across variants
**Categories:**
- `categories`: Array of collections/categories this product belongs to (if includeCategories enabled)
- `categoriesCount`: Number of categories
**Images:**
- `images`: Array of all product images with metadata
- `featuredImage`: URL of the main product image
- `imagesCount`: Total number of images
**Variants:** (if includeVariants enabled)
- `variants`: Array of all product variants
- `variantsCount`: Total number of variants
**Options:**
- `options`: Product option configurations (Size, Color, etc.)
**Description:**
- `description`: Plain text description (if includeDescription enabled)
- `descriptionHtml`: HTML formatted description (if includeDescription enabled)
#### Example Product Output
```json
{
"type": "product",
"id": 1234567890,
"title": "Amazing Product",
"handle": "amazing-product",
"url": "https://store.myshopify.com/products/amazing-product",
"vendor": "Brand Name",
"productType": "Electronics",
"tags": ["new", "featured", "sale"],
"createdAt": "2024-01-15T10:30:00Z",
"publishedAt": "2024-01-16T08:00:00Z",
"updatedAt": "2024-03-20T15:45:00Z",
"price": "99.99",
"priceMax": "149.99",
"compareAtPrice": "129.99",
"compareAtPriceMax": "159.99",
"currency": "USD",
"onSale": true,
"stockStatus": "InStock",
"availableForSale": true,
"totalInventory": 150,
"availableVariants": 3,
"totalVariants": 6,
"taxable": true,
"allVariantsTaxable": true,
"skus": ["ABC-001", "ABC-002", "ABC-003"],
"description": "Full product description...",
"descriptionHtml": "Full product description...
",
"featuredImage": "https://cdn.shopify.com/...",
"imagesCount": 5,
"images": [
{
"id": 12345,
"src": "https://cdn.shopify.com/...",
"alt": "Product image",
"width": 2048,
"height": 2048
}
],
"variantsCount": 6,
"variants": [
{
"id": 98765,
"title": "Small / Black",
"sku": "ABC-001",
"barcode": "123456789012",
"price": "99.99",
"compareAtPrice": "129.99",
"available": true,
"inventoryQuantity": 45,
"inventoryManagement": "shopify",
"inventoryPolicy": "deny",
"taxable": true,
"taxCode": null,
"option1": "Small",
"option2": "Black",
"option3": null,
"weight": 500,
"weightUnit": "g",
"requiresShipping": true,
"fulfillmentService": "manual"
}
],
"options": [
{
"name": "Size",
"position": 1,
"values": ["Small", "Medium", "Large"]
},
{
"name": "Color",
"position": 2,
"values": ["Black", "White", "Red"]
}
],
"categoriesCount": 2,
"categories": [
{
"id": 111111,
"handle": "best-sellers",
"title": "Best Sellers",
"url": "https://store.myshopify.com/collections/best-sellers"
},
{
"id": 222222,
"handle": "electronics",
"title": "Electronics",
"url": "https://store.myshopify.com/collections/electronics"
}
]
}
```
#### Collection Data
```json
{
"type": "collection",
"id": 123456,
"handle": "best-sellers",
"title": "Best Sellers",
"url": "https://store.myshopify.com/collections/best-sellers",
"description": "Our top selling products...",
"productsCount": 24,
"updatedAt": "2024-03-15T12:00:00Z"
}
```
### Anti-Bot Protection Bypass
This actor implements multiple techniques to bypass Shopify's anti-bot protection:
1. **Randomized Headers**: Uses realistic browser headers that rotate with each request
2. **User-Agent Rotation**: Cycles through multiple modern browser user agents
3. **Rate Limiting**: Smart delays between requests (1-3 seconds)
4. **Retry Logic**: Exponential backoff for rate-limited requests
5. **Proxy Support**: Compatible with Apify's residential proxy network
6. **JSON API Access**: Uses Shopify's public JSON endpoints (faster and more reliable)
#### Recommended Proxy Configuration
For stores with strict bot protection, use residential proxies:
```json
{
"proxyConfiguration": {
"useApifyProxy": true,
"apifyProxyGroups": ["RESIDENTIAL"]
}
}
```
### Currency Support
The actor supports Shopify's multi-currency feature. Simply specify the desired currency code:
```json
{
"currency": "EUR"
}
```
Supported currencies include: USD, EUR, GBP, CAD, AUD, JPY, and all other ISO 4217 currency codes.
### Stock Status Detection
The actor automatically detects product availability:
- **InStock**: Product or at least one variant is available
- **OutOfStock**: All variants are unavailable
Stock detection includes:
- Variant-level availability
- Inventory quantities
- Inventory management settings
- Product-level availability flags
### Performance & Limits
- **Speed**: ~500-1000 products per minute (depending on store and proxy)
- **Scalability**: Handles stores with 100,000+ products
- **Memory**: ~256MB RAM recommended
- **Timeout**: 30 seconds per request with automatic retries
### Best Practices
1. **Use Proxies**: Enable residential proxies for stores with strict protection
2. **Limit Products**: Use `maxProducts` for testing to avoid long runs
3. **Currency**: Always specify currency for accurate pricing
4. **Rate Limiting**: The actor automatically handles rate limiting - don't reduce delays
5. **Error Handling**: Check actor logs for any failed requests
### Troubleshooting
#### Access Denied (403 Error)
- Enable residential proxies in proxy configuration
- Some stores block datacenter IPs
#### Rate Limited (429 Error)
- The actor automatically handles this with exponential backoff
- Consider reducing concurrent requests if issues persist
#### Missing Products
- Some products may be unlisted or password-protected
- Check if the store requires authentication
#### Incorrect Prices
- Verify the currency code is correct
- Some stores may not support all currencies
### SEO Keywords
shopify scraper, shopify product scraper, shopify data extraction, shopify api scraper, ecommerce scraper, product price monitoring, shopify inventory scraper, shopify collection scraper, shopify store data, extract shopify products, shopify web scraping, apify shopify, shopify crawler, shopify product extractor, shopify data mining
### Support & Feedback
- **Issues**: Report bugs via GitHub or Apify Console
- **Feature Requests**: Suggest improvements in the actor discussion
- **Documentation**: Full API docs available on Apify
### License
Apache-2.0
***
**Ready to extract Shopify data?** Click the "Try for free" button and start scraping in minutes!
# Actor input Schema
## `startUrls` (type: `array`):
List of Shopify store URLs to scrape (e.g., https://example.myshopify.com)
## `mode` (type: `string`):
Choose what to scrape from the store
## `collectionUrls` (type: `array`):
Specific collection URLs to scrape products from. Only used when mode is PRODUCTS. Example: https://store.myshopify.com/collections/best-sellers
## `productUrls` (type: `array`):
Specific product URLs to scrape. Only used when mode is SINGLE\_PRODUCT. Example: https://store.myshopify.com/products/product-name
## `currency` (type: `string`):
ISO currency code for prices (e.g., USD, EUR, GBP, CAD, AUD). Leave empty for store default.
## `checkStock` (type: `boolean`):
Detect if products are in stock or out of stock
## `maxProducts` (type: `integer`):
Maximum number of products to scrape (leave empty for unlimited)
## `maxCollections` (type: `integer`):
Maximum number of collections to scrape (leave empty for unlimited)
## `includeVariants` (type: `boolean`):
Include all product variants with individual pricing and inventory data
## `includeImages` (type: `boolean`):
Include all product images with metadata (URL, dimensions, alt text)
## `includeDescription` (type: `boolean`):
Include full product descriptions (text and HTML)
## `includeCategories` (type: `boolean`):
Include the collections/categories that each product belongs to. Note: This may slow down scraping as it requires fetching all collections.
## `proxyConfiguration` (type: `object`):
Proxy settings. Recommended to use residential proxies for stores with strict bot protection.
## Actor input object example
```json
{
"startUrls": [
{
"url": "https://example.myshopify.com"
}
],
"mode": "PRODUCTS",
"currency": "USD",
"checkStock": true,
"includeVariants": true,
"includeImages": true,
"includeDescription": true,
"includeCategories": 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 = {
"startUrls": [
{
"url": "https://example.myshopify.com"
}
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("xquantify/shopify-store-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 = { "startUrls": [{ "url": "https://example.myshopify.com" }] }
# Run the Actor and wait for it to finish
run = client.actor("xquantify/shopify-store-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 '{
"startUrls": [
{
"url": "https://example.myshopify.com"
}
]
}' |
apify call xquantify/shopify-store-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=xquantify/shopify-store-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Shopify Store Scraper - Products & Collections Extractor",
"description": "Extract products, collections & inventory from any Shopify store. Multi-currency support, stock detection, anti-bot bypass. Fast, reliable & easy to use.",
"version": "0.0",
"x-build-id": "cpJ5G9A4EkkclcbOo"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/xquantify~shopify-store-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-xquantify-shopify-store-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/xquantify~shopify-store-scraper/runs": {
"post": {
"operationId": "runs-sync-xquantify-shopify-store-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/xquantify~shopify-store-scraper/run-sync": {
"post": {
"operationId": "run-sync-xquantify-shopify-store-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": [
"startUrls",
"mode"
],
"properties": {
"startUrls": {
"title": "Start URLs",
"type": "array",
"description": "List of Shopify store URLs to scrape (e.g., https://example.myshopify.com)",
"items": {
"type": "object",
"required": [
"url"
],
"properties": {
"url": {
"type": "string",
"title": "URL of a web page",
"format": "uri"
}
}
}
},
"mode": {
"title": "Scraping Mode",
"enum": [
"PRODUCTS",
"COLLECTIONS",
"SINGLE_PRODUCT",
"ALL"
],
"type": "string",
"description": "Choose what to scrape from the store",
"default": "PRODUCTS"
},
"collectionUrls": {
"title": "Collection URLs (Optional)",
"type": "array",
"description": "Specific collection URLs to scrape products from. Only used when mode is PRODUCTS. Example: https://store.myshopify.com/collections/best-sellers",
"items": {
"type": "string"
}
},
"productUrls": {
"title": "Product URLs (Optional)",
"type": "array",
"description": "Specific product URLs to scrape. Only used when mode is SINGLE_PRODUCT. Example: https://store.myshopify.com/products/product-name",
"items": {
"type": "string"
}
},
"currency": {
"title": "Currency Code",
"type": "string",
"description": "ISO currency code for prices (e.g., USD, EUR, GBP, CAD, AUD). Leave empty for store default."
},
"checkStock": {
"title": "Check Stock Status",
"type": "boolean",
"description": "Detect if products are in stock or out of stock",
"default": true
},
"maxProducts": {
"title": "Max Products",
"minimum": 1,
"type": "integer",
"description": "Maximum number of products to scrape (leave empty for unlimited)"
},
"maxCollections": {
"title": "Max Collections",
"minimum": 1,
"type": "integer",
"description": "Maximum number of collections to scrape (leave empty for unlimited)"
},
"includeVariants": {
"title": "Include Product Variants",
"type": "boolean",
"description": "Include all product variants with individual pricing and inventory data",
"default": true
},
"includeImages": {
"title": "Include Product Images",
"type": "boolean",
"description": "Include all product images with metadata (URL, dimensions, alt text)",
"default": true
},
"includeDescription": {
"title": "Include Descriptions",
"type": "boolean",
"description": "Include full product descriptions (text and HTML)",
"default": true
},
"includeCategories": {
"title": "Include Categories (Collections)",
"type": "boolean",
"description": "Include the collections/categories that each product belongs to. Note: This may slow down scraping as it requires fetching all collections.",
"default": false
},
"proxyConfiguration": {
"title": "Proxy Configuration",
"type": "object",
"description": "Proxy settings. Recommended to use residential proxies for stores with strict bot protection."
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```