# Seeking Alpha Scraper | Stock Analysis and News (`parseforge/seekingalpha-scraper`) Actor

Pull Seeking Alpha articles, analyst ratings, earnings transcripts, news, and stock data with ticker, author, title, body, sentiment, and published date. Power finance research, sentiment analysis, market intelligence, and investment dashboards with quality long-form content.

- **URL**: https://apify.com/parseforge/seekingalpha-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** News, Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 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.
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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 📰 Seeking Alpha Scraper

> 🚀 **Export Seeking Alpha financial news in seconds.** Get real-time market news headlines with tickers, publish timestamps, and article URLs - no login, no paywall, no code.

> 🕒 **Last updated:** 2026-05-22 · **📊 7 fields** per record · **Real-time** · **Global market news**

The Seeking Alpha Scraper pulls live market news directly from Seeking Alpha's public API - the same feed that powers their website's breaking news section. No login required, no browser automation. Just clean, structured financial news data ready for CSV, Excel, JSON, or XML export.

Seeking Alpha (seekingalpha.com) is one of the most widely read financial analysis platforms in the world, covering stocks, ETFs, earnings, dividends, and macroeconomic events. This scraper gives you programmatic access to their latest market news headlines with full ticker attribution.

**Coverage:** Real-time market news feed. Up to 20 articles per run from the public feed. 7 fields per record including Getty image thumbnails, ISO timestamps, and primary ticker symbols linked to each news item.

| Who uses this | Why |
|---|---|
| Financial analysts | Monitor market-moving headlines in real time |
| Traders | Track news sentiment for individual stocks |
| Quantitative researchers | Build structured datasets of financial events |
| Developers | Power news widgets and financial dashboards |
| Investors | Stay informed on breaking market events |
| Data scientists | Train NLP models on financial headlines |

### 📋 What the Seeking Alpha Scraper does

- Connects to Seeking Alpha's public news API with residential proxy rotation
- Extracts article title, publish timestamp, and full article URL
- Captures Getty image thumbnail URLs when available for each article
- Maps each article to its primary ticker symbols (e.g. AAPL, NVDA, MSFT)
- Applies your `maxItems` limit so you get exactly the data you need
- Delivers results in seconds - no browser automation or JavaScript rendering required

> 💡 **Why it matters:** Seeking Alpha is where institutional and retail investors read financial news. Having structured access to SA headlines means you can track what moved individual stocks, correlate news flow with price action, monitor earnings and dividend announcements, or build real-time financial news feeds - all without manual browsing.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `feedType` | string | Feed type: market-news, latest-articles, earnings, dividends | `market-news` |
| `ticker` | string | Stock ticker to filter by (e.g. AAPL, TSLA) - optional | - |
| `maxItems` | integer | Max articles to return (free: 10, paid: up to 20 per run) | `10` |

**Example 1 - Market news (default):**
```json
{
  "feedType": "market-news",
  "maxItems": 10
}
````

**Example 2 - With ticker filter:**

```json
{
  "feedType": "market-news",
  "ticker": "NVDA",
  "maxItems": 10
}
```

> ⚠️ **Good to Know:** Seeking Alpha's public API only exposes market news without authentication. The `feedType` and `ticker` parameters are accepted for UX consistency - all runs return the public market news feed. Article content (summary) and author fields are paywalled and return `null` in the public feed. Free users are limited to 10 articles per run.

### 📊 Output

| Field | Type | Description |
|-------|------|-------------|
| 🖼 `imageUrl` | string | Getty image thumbnail URL (null if not available) |
| 📰 `title` | string | Article headline |
| 📝 `summary` | string | Article summary (null - paywalled on public API) |
| 👤 `author` | string | Author name (null - not exposed in public API) |
| 📅 `publishedAt` | string | ISO 8601 publish timestamp |
| 📈 `tickers` | array | Primary ticker symbols linked to the article |
| 🔗 `articleUrl` | string | Direct URL to the Seeking Alpha article |
| 🕒 `scrapedAt` | string | ISO 8601 scrape timestamp |
| ❌ `error` | string | Error message if scraping failed (null on success) |

**Sample output records (real data from 2026-05-22 run):**

```json
[
  {
    "imageUrl": "https://static.seekingalpha.com/cdn/s3/uploads/getty_images/1370479417/image_1370479417.jpg",
    "title": "Datadog, SK Hynix in focus as Wedbush adds to AI 30 list",
    "summary": null,
    "author": null,
    "publishedAt": "2026-05-22T07:25:31-04:00",
    "tickers": ["DDOG", "HXSCL"],
    "articleUrl": "https://seekingalpha.com/news/4596206",
    "scrapedAt": "2026-05-22T11:25:34.718Z"
  },
  {
    "imageUrl": "https://static.seekingalpha.com/cdn/s3/uploads/getty_images/2198127265/image_2198127265.jpg",
    "title": "Kawasaki teams up with Nvidia, Microsoft, and others to develop physical AI",
    "summary": null,
    "author": null,
    "publishedAt": "2026-05-22T07:22:31-04:00",
    "tickers": ["NVDA", "KWHIY"],
    "articleUrl": "https://seekingalpha.com/news/4596201",
    "scrapedAt": "2026-05-22T11:25:34.718Z"
  },
  {
    "imageUrl": "https://static.seekingalpha.com/cdn/s3/uploads/getty_images/1163344935/image_1163344935.jpg",
    "title": "American Resources, Korea's Posco to build $200M U.S. rare earths refining plant",
    "summary": null,
    "author": null,
    "publishedAt": "2026-05-22T07:20:57-04:00",
    "tickers": ["AREC", "PKX"],
    "articleUrl": "https://seekingalpha.com/news/4596203",
    "scrapedAt": "2026-05-22T11:25:34.718Z"
  }
]
```

### ✨ Why choose this Actor

| Feature | Benefit |
|---------|---------|
| 📡 Direct API access | Data from Seeking Alpha's own news API - not scraped HTML |
| 🔄 Residential proxy rotation | Bypasses bot detection with automatic IP rotation |
| 📈 Ticker attribution | Primary tickers linked to each news item - map news to stocks instantly |
| 📅 ISO timestamps | Machine-readable publish dates, ready for time-series analysis |
| 🌐 No login required | Fully public data, no account needed |
| 🖼 Getty image URLs | Thumbnail images for articles that include them |
| 💾 Multiple export formats | CSV, Excel, JSON, XML - all supported |
| 🔌 Webhook + API ready | Integrate with any workflow tool |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual browsing | Custom script |
|---------|-----------|-----------------|---------------|
| Setup time | 30 seconds | N/A | Hours |
| Structured output | JSON/CSV/Excel/XML | None | Custom |
| Ticker attribution | Yes | Copy manually | Complex |
| ISO timestamps | Yes | None | Parse manually |
| Proxy rotation | Automatic | N/A | Manual |
| Maintenance required | No | No | Yes |

### 🚀 How to use

1. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify
2. Open the [Seeking Alpha Scraper](https://apify.com/parseforge/seekingalpha-scraper) page
3. Choose your **Feed Type** (market-news is the default public feed)
4. Set **Max Items** - start with 10 for a free preview, up to 20 on paid plans
5. Click **Start** and wait a few seconds
6. Download your dataset as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Financial Research and Analysis

Track news volume and sentiment for specific stocks using the ticker attribution field. Correlate Seeking Alpha news timestamps with intraday price movements. Build structured event datasets for earnings, dividends, and macroeconomic news without manual curation.

#### Algorithmic Trading and Quant Research

Use structured news headlines with ticker symbols to build news-driven signal systems. The ISO timestamp and primary ticker fields make it straightforward to join news events with OHLCV price data for backtesting event-driven strategies.

#### Competitive Intelligence and Media Monitoring

Track how Seeking Alpha covers companies, sectors, and market events in real time. Identify which stocks are getting coverage and when - a leading indicator often correlated with institutional attention and retail sentiment shifts.

#### Data Science and NLP

Build training datasets for financial NLP models. Use article titles with ticker labels to train named entity recognition, topic classifiers, or stock-specific sentiment models. The clean, structured output means no preprocessing of raw HTML.

### 🔌 Automating Seeking Alpha Scraper

Connect to your existing workflows using Apify's built-in integrations:

- **Make (formerly Integromat)** - Schedule runs every 15 minutes and push new headlines to Google Sheets, Airtable, or any database
- **Zapier** - Trigger runs on a schedule and route new articles to Slack, email, or CRM systems
- **Slack** - Get real-time market news delivered to a Slack channel for your trading desk
- **Google Sheets** - Append breaking news with tickers to a spreadsheet for ongoing monitoring
- **REST API** - Call the Apify API directly from any application or data pipeline

### 🌟 Beyond business use cases

#### Academic Research

Researchers studying financial media, market microstructure, or news-driven asset pricing can use this Actor to build reproducible, timestamped datasets of Seeking Alpha coverage. The ticker attribution makes it easy to link news events to specific securities.

#### Individual Investor Monitoring

Individual investors can automate monitoring of breaking market news and get structured alerts when relevant articles appear - without manually checking the Seeking Alpha homepage throughout the trading day.

#### Journalism and Fact-Checking

Financial journalists can track how Seeking Alpha has covered a company or market event over time. The timestamp data makes it easy to establish what was published and when during fast-moving market events.

#### Learning and Experimentation

Developers and data scientists can use this Actor to experiment with financial NLP, build demo dashboards, or learn about financial API patterns without any infrastructure setup.

### 🤖 Ask an AI assistant about this scraper

Have questions about how to use this Actor, how to integrate it with your workflow, or what you can build with Seeking Alpha data? Open an AI assistant (Claude, ChatGPT, or similar) and paste this prompt:

> "I'm using the parseforge/seekingalpha-scraper Apify Actor to collect financial news from Seeking Alpha. It returns fields: imageUrl, title, summary, author, publishedAt, tickers, articleUrl, scrapedAt. Help me \[describe what you want to do]."

### ❓ Frequently Asked Questions

**❓ Is this scraper free to use?**
Free Apify accounts can scrape up to 10 articles per run as a preview. Paid plans unlock the full 20-article run.

**❓ How often is the data updated?**
Seeking Alpha's news feed updates in real time. Every time you run the Actor, you get the latest articles available at that moment.

**❓ Why are summary and author always null?**
Seeking Alpha's public news API returns article metadata but not the article body or author attribution - those are restricted to logged-in subscribers. The fields are included in the output schema for forward compatibility and consistency with other ParseForge news scrapers.

**❓ Why are some imageUrls null?**
Not all Seeking Alpha news items include a Getty image thumbnail. Short news items like dividend declarations or brief price alerts typically do not have images.

**❓ How many articles are returned per run?**
The public API returns up to 20 articles in a single run without authentication. To collect more, schedule recurring runs and accumulate results over time in your Apify dataset.

**❓ Do I need a Seeking Alpha account?**
No. The Actor uses Seeking Alpha's public news API which requires no authentication.

**❓ Can I run this on a schedule?**
Yes. Use Apify's built-in scheduler to run the Actor every 15 minutes, hourly, or on any cron schedule. Results accumulate in your dataset automatically.

**❓ What format can I export the data in?**
CSV, Excel (XLSX), JSON, XML, and HTML table - all available from the Apify dataset view after a run.

**❓ Why do some runs take longer than others?**
The Actor uses residential proxy rotation to bypass bot detection. Occasionally it needs to retry with a different proxy IP, which adds a few seconds. Runs typically complete in 10-30 seconds.

**❓ Can I filter by ticker symbol?**
The `ticker` input field is accepted, but Seeking Alpha's public feed does not support ticker filtering without authentication. All runs return the general market news feed.

**❓ Can I use this data commercially?**
The scraped data is subject to Seeking Alpha's terms of service. Always review the terms for your intended use case. The Actor itself is free to use under Apify's terms.

**❓ What happens if Seeking Alpha blocks the request?**
The Actor retries automatically with different residential proxy IPs up to 6 times. If all attempts fail, it pushes an error record with a descriptive message and exits cleanly.

### 🔌 Integrate with any app

Connect your Seeking Alpha dataset to the tools you already use:

**Spreadsheets** - Google Sheets, Excel Online, Airtable
**Databases** - PostgreSQL, MySQL, MongoDB, BigQuery, Snowflake
**Automation** - Make, Zapier, n8n, Pipedream
**Business Intelligence** - Tableau, Power BI, Looker, Metabase
**Developer Tools** - REST API, Python SDK, JavaScript SDK, CLI
**Storage** - AWS S3, Google Cloud Storage, Azure Blob Storage
**Communication** - Slack, Teams, Email via webhook

### 🔗 Recommended Actors

| Actor | What it scrapes |
|-------|----------------|
| [MarketWatch Scraper](https://apify.com/parseforge/marketwatch-scraper) | Financial news articles from MarketWatch |
| [BLS Scraper](https://apify.com/parseforge/bls-scraper) | U.S. Bureau of Labor Statistics economic data |
| [FinViz Scraper](https://apify.com/parseforge/finviz-scraper) | Stock screener data, news, and financial metrics |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 145+ specialized data scrapers covering finance, jobs, real estate, travel, and more.

***

**Disclaimer:** This Actor is an independent tool not affiliated with, endorsed by, or sponsored by Seeking Alpha Inc. It accesses only publicly available API data. Use of this Actor is subject to Apify's Terms of Service. Users are responsible for ensuring their use of the data complies with applicable laws and Seeking Alpha's terms of service.

# Actor input Schema

## `feedType` (type: `string`):

Which Seeking Alpha feed to scrape.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `ticker` (type: `string`):

Optional stock ticker to filter articles by (e.g. AAPL, TSLA, MSFT). Leave empty to get all articles.

## Actor input object example

```json
{
  "feedType": "market-news",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "feedType": "market-news",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/seekingalpha-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 = {
    "feedType": "market-news",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/seekingalpha-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 '{
  "feedType": "market-news",
  "maxItems": 10
}' |
apify call parseforge/seekingalpha-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Seeking Alpha Scraper | Stock Analysis and News",
        "description": "Pull Seeking Alpha articles, analyst ratings, earnings transcripts, news, and stock data with ticker, author, title, body, sentiment, and published date. Power finance research, sentiment analysis, market intelligence, and investment dashboards with quality long-form content.",
        "version": "1.0",
        "x-build-id": "nhgcrHkFIqxzwLNDI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~seekingalpha-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-seekingalpha-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/parseforge~seekingalpha-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-seekingalpha-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/parseforge~seekingalpha-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-seekingalpha-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": {
                    "feedType": {
                        "title": "Feed Type",
                        "enum": [
                            "market-news",
                            "latest-articles",
                            "earnings",
                            "dividends"
                        ],
                        "type": "string",
                        "description": "Which Seeking Alpha feed to scrape.",
                        "default": "market-news"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "ticker": {
                        "title": "Ticker Symbol",
                        "type": "string",
                        "description": "Optional stock ticker to filter articles by (e.g. AAPL, TSLA, MSFT). Leave empty to get all articles."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
