# ShopGoodwill Scraper (`automation-lab/shopgoodwill-scraper`) Actor

Scrape ShopGoodwill auction listings with prices, bids, ending times, images, categories, seller IDs, and listing URLs for resale sourcing.

- **URL**: https://apify.com/automation-lab/shopgoodwill-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## ShopGoodwill Scraper

Extract auction listings from ShopGoodwill search and category pages. The actor returns item titles, current prices, bid counts, ending times, categories, images, seller IDs, and listing URLs so resellers and market analysts can monitor Goodwill inventory without manual copying.

### What does ShopGoodwill Scraper do?

ShopGoodwill Scraper collects public auction/listing records from ShopGoodwill.

It is designed for repeatable sourcing and market-monitoring workflows.

You can search by keyword, pass ShopGoodwill search URLs, or pass category IDs.

The actor paginates through ShopGoodwill results until it reaches your `maxItems` limit.

### Who is it for?

#### Resale and arbitrage sellers

Use ShopGoodwill Scraper to build repeatable sourcing lists for laptops, cameras, jewelry, collectibles, watches, and other second-hand categories. Run narrow searches before auctions close, export the current bid price, bid count, location, and image, then compare candidates against your resale model.

#### Ecommerce and pricing analysts

Track second-hand marketplace pricing by keyword or category. Export current prices, auction status, end times, and category labels into spreadsheets or BI tools to monitor demand, seasonal pricing, and category-level supply.

#### Auction monitors and sourcing teams

Schedule watchlist runs for categories that your team reviews daily. Use the dataset as a lightweight auction monitor: filter by ending time, current price, bids, and listing URL, then route promising lots to Slack, email, or an internal dashboard.

#### Inventory researchers and lead-generation teams

Collect comparable public listings for valuation, product research, or inventory planning. The actor turns ShopGoodwill browsing into a structured dataset that can be enriched with other marketplace, product, or price-monitoring actors.

### Why use it?

ShopGoodwill pages are useful but manual monitoring is repetitive.

This actor creates structured datasets you can filter, export, enrich, and schedule.

It uses ShopGoodwill's public listing API, so no account is required for normal searches.

### Data you can extract

| Field | Description |
| --- | --- |
| itemId | ShopGoodwill item identifier |
| title | Listing title |
| currentPrice | Current auction price |
| bidsCount | Number of bids |
| status | active, stock, ended, or unknown |
| endTime | Auction end time |
| listingUrl | Canonical item URL |
| imageUrl | Primary image URL |
| categoryName | Category label |
| sellerId | Seller/location id |

### How much does it cost to scrape ShopGoodwill listings?

This actor uses pay-per-event pricing with one small run-start charge plus a per-listing `item` charge. The exact billing tier depends on your Apify subscription tier; the table below mirrors the current actor pricing.

| Event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Run started | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 |
| Item extracted | $0.000031393 | $0.000027299 | $0.000021293 | $0.000016379 | $0.000010919 | $0.000010000 |

Realistic examples:

| Run size | Approx. FREE cost | Approx. BRONZE cost | Typical use |
| --- | ---: | ---: | --- |
| 25 listings | $0.0058 | $0.0057 | quick keyword smoke test |
| 100 listings | $0.0081 | $0.0077 | daily sourcing search |
| 500 listings | $0.0207 | $0.0186 | broader category monitor |
| 1,000 listings | $0.0364 | $0.0323 | large watchlist export |

Free-plan estimate: a 100-listing run is usually under one cent before any platform-level free usage credits or other account limits. Start with `maxItems` between 20 and 100 while tuning a search, then increase it for production schedules.

### Input options

`searchTerm` is the easiest way to start.

`startUrls` accepts ShopGoodwill listing URLs, search URLs, category URLs, raw category IDs, or extra keyword strings.

`maxItems` controls the result cap.

`activeOnly` skips ended results when closed auctions are enabled.

`includeClosedAuctions` asks ShopGoodwill for recent closed auctions when available.

`minPrice` and `maxPrice` filter the requested price range.

### Example input

```json
{
  "searchTerm": "laptop",
  "maxItems": 100,
  "activeOnly": true,
  "sortBy": "ending_soon"
}
````

### Example with a ShopGoodwill URL

```json
{
  "startUrls": [
    { "url": "https://shopgoodwill.com/categories/listing?st=camera&p=1&ps=40" }
  ],
  "maxItems": 200
}
```

### Output example

```json
{
  "itemId": 269173602,
  "title": "Vera Bradley Rosy Posies Laptop Tote",
  "currentPrice": 12.99,
  "bidsCount": 0,
  "status": "active",
  "listingUrl": "https://shopgoodwill.com/item/269173602"
}
```

### Tips for good results

Use specific keywords like `sony camera`, `laptop`, `sterling silver`, or `lego`.

Run scheduled searches near auction close times if you need ending-soon inventory.

Set `maxItems` high enough to cover several pages for broad keywords.

Use price filters to avoid low-value or out-of-budget listings.

### Integrations

Export the dataset to CSV for Google Sheets or Airtable.

Send results to a webhook for inventory alerts.

Feed listing URLs into enrichment actors or internal pricing models.

Schedule daily runs for watchlists and sourcing dashboards.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/shopgoodwill-scraper').call({
  searchTerm: 'laptop',
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/shopgoodwill-scraper').call(run_input={
    'searchTerm': 'laptop',
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~shopgoodwill-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchTerm":"laptop","maxItems":100}'
```

### MCP usage

Use Apify MCP to run ShopGoodwill Scraper from Claude Code, Claude Desktop, Cursor, or VS Code-compatible MCP clients.

Claude Code setup:

```bash
claude mcp add apify-shopgoodwill --transport http "https://mcp.apify.com?tools=automation-lab/shopgoodwill-scraper"
```

Claude Desktop, Cursor, or VS Code MCP JSON setup:

```json
{
  "mcpServers": {
    "apify-shopgoodwill": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/shopgoodwill-scraper"
    }
  }
}
```

Example prompts:

- "Run ShopGoodwill Scraper for vintage watch auctions and summarize items ending soon."
- "Find up to 100 laptop auctions, group them by current price band, and return the most promising resale candidates."
- "Monitor camera listings on ShopGoodwill and create a table with item URL, current bid, bids count, and end time."

### Common workflows

Monitor laptops ending soon.

Track camera resale opportunities.

Export jewelry auctions above a target price.

Build a watchlist of categories for sourcing teams.

### Limitations

The actor extracts public listing/search data.

It does not log in or bid on auctions.

Some detail-page-only information may require a future detail enrichment mode.

ShopGoodwill can change API fields, so validate important workflows periodically.

### Troubleshooting

If you get fewer results than expected, increase `maxItems` or broaden the search term.

If a query has no output, test it directly on ShopGoodwill first.

If closed auctions do not appear, verify that ShopGoodwill currently returns closed results for the query.

### Legality

This actor collects publicly available listing information.

Use the output responsibly and respect ShopGoodwill's terms, privacy rules, and applicable laws.

Do not use the actor to spam, bid automatically, or overload the target website.

### Related scrapers

Use these Automation Lab actors with ShopGoodwill Scraper for broader resale and marketplace workflows:

- [HiBid Scraper](https://apify.com/automation-lab/hibid-scraper) for regional auction lots and estate-sale inventory.
- [AuctionNinja Scraper](https://apify.com/automation-lab/auctionninja-scraper) for auction-house listings and local pickup opportunities.
- [eBay Seller Scraper](https://apify.com/automation-lab/ebay-seller-scraper) for reseller benchmarking and sold-inventory research.
- [Mercari Japan Listings Scraper](https://apify.com/automation-lab/mercari-japan-listings-scraper) for cross-market product comparisons.
- [Poshmark Sold Listings Scraper](https://apify.com/automation-lab/poshmark-sold-listings-scraper) for apparel resale price checks.

Combine the outputs with product enrichment, repricing, alerting, or spreadsheet automation actors when building sourcing pipelines.

### Changelog

See `.actor/CHANGELOG.md` for release notes.

### Support

Open an issue on the Apify actor page if a run fails or ShopGoodwill changes its listing format.

### FAQ

#### Do I need a ShopGoodwill account?

No. Public search and category listings do not require login.

#### Can it scrape item detail pages?

The first release focuses on listing/search results. Detail enrichment can be added later.

#### Can I monitor auctions daily?

Yes. Create an Apify schedule with your preferred search input.

#### Does it use a browser?

No. It uses HTTP requests for lower cost and faster runs.

#### Can I export to Excel?

Yes. Download the Apify dataset as CSV or XLSX.

# Actor input Schema

## `searchTerm` (type: `string`):

Keyword to search on ShopGoodwill, such as laptop, camera, jewelry, or vintage watch.

## `startUrls` (type: `array`):

Optional ShopGoodwill search/category URLs or item URLs. URL query filters are converted into API searches.

## `maxItems` (type: `integer`):

Maximum number of auction/listing records to save.

## `activeOnly` (type: `boolean`):

Skip ended listings if closed auctions are included.

## `includeClosedAuctions` (type: `boolean`):

Ask ShopGoodwill to include recently closed auction results when available.

## `closedAuctionDaysBack` (type: `integer`):

Number of days back for closed auction searches.

## `minPrice` (type: `number`):

Minimum current price to request from ShopGoodwill.

## `maxPrice` (type: `number`):

Maximum current price to request from ShopGoodwill.

## `sortBy` (type: `string`):

Choose a ShopGoodwill listing sort mode.

## Actor input object example

```json
{
  "searchTerm": "laptop",
  "startUrls": [
    {
      "url": "https://shopgoodwill.com/categories/listing?st=laptop&sg=&c=&s=&lp=0&hp=999999&sbn=false&spo=false&snpo=false&socs=false&sd=false&sca=false&cadb=7&scs=false&sis=false&col=1&p=1&ps=40&desc=false&ss=0&UseBuyerPrefs=true"
    }
  ],
  "maxItems": 20,
  "activeOnly": false,
  "includeClosedAuctions": false,
  "closedAuctionDaysBack": 7,
  "minPrice": 0,
  "maxPrice": 20,
  "sortBy": "ending_soon"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerm": "laptop",
    "startUrls": [
        {
            "url": "https://shopgoodwill.com/categories/listing?st=laptop&sg=&c=&s=&lp=0&hp=999999&sbn=false&spo=false&snpo=false&socs=false&sd=false&sca=false&cadb=7&scs=false&sis=false&col=1&p=1&ps=40&desc=false&ss=0&UseBuyerPrefs=true"
        }
    ],
    "maxItems": 20,
    "activeOnly": false,
    "includeClosedAuctions": false,
    "closedAuctionDaysBack": 7,
    "minPrice": 0,
    "maxPrice": 20,
    "sortBy": "ending_soon"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/shopgoodwill-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchTerm": "laptop",
    "startUrls": [{ "url": "https://shopgoodwill.com/categories/listing?st=laptop&sg=&c=&s=&lp=0&hp=999999&sbn=false&spo=false&snpo=false&socs=false&sd=false&sca=false&cadb=7&scs=false&sis=false&col=1&p=1&ps=40&desc=false&ss=0&UseBuyerPrefs=true" }],
    "maxItems": 20,
    "activeOnly": False,
    "includeClosedAuctions": False,
    "closedAuctionDaysBack": 7,
    "minPrice": 0,
    "maxPrice": 20,
    "sortBy": "ending_soon",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/shopgoodwill-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 '{
  "searchTerm": "laptop",
  "startUrls": [
    {
      "url": "https://shopgoodwill.com/categories/listing?st=laptop&sg=&c=&s=&lp=0&hp=999999&sbn=false&spo=false&snpo=false&socs=false&sd=false&sca=false&cadb=7&scs=false&sis=false&col=1&p=1&ps=40&desc=false&ss=0&UseBuyerPrefs=true"
    }
  ],
  "maxItems": 20,
  "activeOnly": false,
  "includeClosedAuctions": false,
  "closedAuctionDaysBack": 7,
  "minPrice": 0,
  "maxPrice": 20,
  "sortBy": "ending_soon"
}' |
apify call automation-lab/shopgoodwill-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/shopgoodwill-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ShopGoodwill Scraper",
        "description": "Scrape ShopGoodwill auction listings with prices, bids, ending times, images, categories, seller IDs, and listing URLs for resale sourcing.",
        "version": "0.1",
        "x-build-id": "qB4Bh7EpLt9NKBodM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~shopgoodwill-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-shopgoodwill-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/automation-lab~shopgoodwill-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-shopgoodwill-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/automation-lab~shopgoodwill-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-shopgoodwill-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",
                "properties": {
                    "searchTerm": {
                        "title": "Search term",
                        "type": "string",
                        "description": "Keyword to search on ShopGoodwill, such as laptop, camera, jewelry, or vintage watch."
                    },
                    "startUrls": {
                        "title": "ShopGoodwill URLs or category IDs",
                        "type": "array",
                        "description": "Optional ShopGoodwill search/category URLs or item URLs. URL query filters are converted into API searches.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of auction/listing records to save.",
                        "default": 20
                    },
                    "activeOnly": {
                        "title": "Active listings only",
                        "type": "boolean",
                        "description": "Skip ended listings if closed auctions are included.",
                        "default": false
                    },
                    "includeClosedAuctions": {
                        "title": "Include closed auctions",
                        "type": "boolean",
                        "description": "Ask ShopGoodwill to include recently closed auction results when available.",
                        "default": false
                    },
                    "closedAuctionDaysBack": {
                        "title": "Closed auction lookback days",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Number of days back for closed auction searches.",
                        "default": 7
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Minimum current price to request from ShopGoodwill.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Maximum current price to request from ShopGoodwill.",
                        "default": 20
                    },
                    "sortBy": {
                        "title": "Sort listings by",
                        "enum": [
                            "ending_soon",
                            "newest",
                            "price_low",
                            "price_high"
                        ],
                        "type": "string",
                        "description": "Choose a ShopGoodwill listing sort mode.",
                        "default": "ending_soon"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
