# AI Web Search — Live SERP API for Agents (Tavily Alternative) (`logiover/ai-web-search`) Actor
Keyless live web search for AI agents and RAG. Send a query, get clean ranked results (title, URL, snippet) from DuckDuckGo + Bing, with optional page content as Markdown. A Tavily / Exa / Brave Search alternative. No API key.
- **URL**: https://apify.com/logiover/ai-web-search.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Agents, AI, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $3.50 / 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
## AI Web Search — Live SERP API for AI Agents, RAG & Grounding (Tavily / Exa / SerpAPI Alternative, No API Key)
    
Give it a query, get **clean, ranked web results your LLM can actually use.** AI Web Search is a fast, **keyless live search API** built for **AI agents, RAG and grounding** — a practical **Tavily / Exa / Brave Search / SerpAPI alternative**. Send one query or a batch of a hundred and receive structured results — **title, URL, snippet, source domain and rank** — pulled **live from the web**, with an optional **Markdown copy of each result page** attached for instant grounding.
Large language models have a knowledge cutoff and **hallucinate about anything recent**. This Actor fixes that: it hands your agent **fresh, real search results with sources it can cite**, instead of guesses. **No API key, no browser, no rate-limit headaches — just search.**
> ### 🏆 Why this AI web search Actor?
> **12 fields per result** · **up to 100 queries per run** · **dual engine (DuckDuckGo + Bing fallback)** · optional **Markdown page content** for RAG · direct HTTP, no browser · export to JSON / CSV / Excel. The unofficial **keyless search API** for agents that need to ground answers in the live web — one charge per returned result.
---
### ✨ What this Actor does / Key features
- 🔎 **Live web search** — send a query, get back the top-ranked results the search engines are serving *right now*, not stale training data.
- 🧠 **Built for AI agents & RAG** — predictable, flat schema (title, URL, snippet, source, rank) that drops straight into a prompt, a tool call, or a vector store.
- 🛡️ **Resilient dual engine** — **DuckDuckGo HTML** is the primary source; if it returns nothing, the Actor automatically **falls back to Bing**, so you get results, not empty responses.
- 📝 **Grounding built in** — enable **Include page content** and each result carries the page's main text as **clean Markdown** (`content` + `contentWordCount`), ready to paste into a grounding prompt.
- 📚 **Batch queries** — fire up to **100 queries** in a single run with configurable concurrency (1–10 in parallel).
- 🌍 **Region & language control** — `us-en`, `uk-en`, `de-de`, `fr-fr`, `es-es` and more, plus a safe-search toggle.
- 🔑 **Keyless** — no Tavily, Exa, Brave, Bing or SerpAPI key. Runs on plain HTTP with Apify's proxy.
- 🤖 **Agent-native (MCP + pay-per-event)** — one charge per returned result, so an AI agent can discover the Actor, search, and reason over the output with no account setup.
- ⚡ **Fast & cheap** — direct HTTP extraction on a small container; no headless Chrome, no idle cost.
### 🚀 Quick start (3 steps)
1. **Configure** — type one or more queries into **Search queries** (batch list) or drop a single query into **Single query**. Set **Max results per query** (default 10).
2. **Run** — click **Start**. The Actor fans out your queries, ranks each result, and streams rows into your dataset.
3. **Get your data** — open the **Output** tab and export to **JSON, CSV, Excel or XML**, or read it live via the Apify API / MCP.
> 💡 Turn on **Include page content** if you want each result page's main text as Markdown for grounding — great for RAG, slightly slower (one fetch per result).
### 📥 Input
Give the Actor at least one query — either the **`queries`** batch list or the single **`query`** field. Everything else is optional.
#### Example — ground an agent on a fresh topic
```json
{
"queries": ["what is the model context protocol", "MCP server security best practices 2026"],
"maxResults": 10,
"includeContent": true,
"region": "us-en"
}
````
#### Example — batch research questions (ranked sources only)
```json
{
"queries": [
"best open source vector databases 2026",
"RAG chunking strategies compared",
"hybrid search BM25 vs embeddings"
],
"maxResults": 15,
"concurrency": 5,
"region": "us-en"
}
```
#### Example — single localized query
```json
{
"query": "beste günstige elektroautos 2026",
"maxResults": 20,
"region": "de-de",
"safeSearch": true
}
```
| Field | Type | Description |
|-------|------|-------------|
| `queries` | array | One or more search queries. Batch up to **100**. Use this or `query`. |
| `query` | string | A single search query. Use this or `queries`. |
| `maxResults` | integer | Ranked results to return per query, **1–30** (default 10). |
| `includeContent` | boolean | Fetch each result page and attach its main content as clean **Markdown** (`content`). Slower; adds one fetch per result. |
| `region` | string | Region / language code, e.g. `us-en`, `uk-en`, `de-de`, `fr-fr`, `es-es`. |
| `safeSearch` | boolean | Filter explicit results (default true). |
| `concurrency` | integer | How many queries to run in parallel, **1–10** (default 3). |
| `useApifyProxy` | boolean | Route requests through Apify datacenter proxy (recommended, avoids per-IP rate limits). |
| `proxyGroups` | array | Advanced: override proxy group, e.g. `RESIDENTIAL`. Empty = datacenter (AUTO). |
### 📤 Output
One row per search result — **12 fields**, exportable to JSON, CSV, Excel or XML. Here is a trimmed sample record:
```json
{
"query": "what is the model context protocol",
"rank": 1,
"engine": "duckduckgo",
"title": "Model Context Protocol — An open standard for AI tools",
"url": "https://modelcontextprotocol.io",
"displayUrl": "modelcontextprotocol.io",
"source": "modelcontextprotocol.io",
"snippet": "MCP is an open protocol that standardizes how applications provide context to LLMs...",
"content": "# Model Context Protocol\n\nMCP is an open standard that lets AI applications connect to tools and data sources...",
"contentWordCount": 812,
"error": null,
"fetchedAt": "2026-07-06T12:00:00.000Z"
}
```
> When **Include page content** is off, `content` and `contentWordCount` are `null` and you get pure ranked SERP rows.
📋 Full field reference (click to expand)
| Field | Description |
|-------|-------------|
| `query` | The search query that produced this result |
| `rank` | Position in the results (1 = top) |
| `engine` | Which engine served the result (`duckduckgo` / `bing`) |
| `title` | Result title |
| `url` | Destination URL |
| `displayUrl` | Human-readable URL as shown in the SERP |
| `source` | Source domain (e.g. `modelcontextprotocol.io`) |
| `snippet` | Result summary / description text |
| `content` | (Optional) main page content as clean Markdown — only when `includeContent` is on |
| `contentWordCount` | Word count of the fetched Markdown content |
| `error` | Per-row error message, if a page fetch failed (otherwise null) |
| `fetchedAt` | Capture timestamp (ISO 8601) |
### 💡 Use cases
- **RAG & grounding** — give an LLM fresh, citable sources instead of stale training data, with the page text already as Markdown.
- **AI agents** — a "search the web" tool an agent can call mid-conversation and pay per result, no key provisioning.
- **Research automation** — batch dozens of questions and collect ranked sources in one run.
- **Answer engines & chatbots** — power a bot that answers with links and citations, not hallucinations.
- **Monitoring & discovery** — track what ranks for a topic over time, or surface fresh pages on a subject.
- **Fact-checking pipelines** — pull top sources for a claim and let a downstream model reconcile them.
### 👥 Who uses it
AI engineers & agent builders · RAG / LLM app developers · data scientists doing research automation · founders shipping answer engines and chatbots · growth & SEO teams tracking live rankings · analysts who need cited, up-to-date sources at scale.
### 💰 Pricing
This Actor runs on Apify's **pay-per-event** model — you pay **one charge per returned result**, with no monthly fee and no idle cost. That makes it ideal for AI agents that search on demand: pay only for the results you actually get. Try it on the **free tier** first, then scale up. See the **Pricing** tab on this page for the current rate.
### ❓ Frequently Asked Questions
**Is this a Tavily / Exa / Brave Search / SerpAPI alternative?**
Yes. It covers the core "AI web search / grounding" job those APIs are used for — ranked results plus optional page content — without their API keys. You run it on Apify and pay per result.
**Do I need an API key or a login?**
No. It's fully **keyless** and works out of the box with Apify's datacenter proxy. No search-engine account, no API key — only an Apify account.
**Can I search without an API or a browser?**
Yes. There's no headless browser and no third-party search API involved — the Actor pulls results over direct HTTP. That's what keeps it fast and cheap.
**Where do the results come from?**
**DuckDuckGo HTML first**, with an automatic **Bing fallback** for resilience — so you get the cleanest available results instead of empty responses.
**Can it return page content, not just snippets?**
Yes — enable **Include page content** and each result carries the page's main content as clean **Markdown** (with a `contentWordCount`), ideal for RAG and grounding.
**How much data can I get?**
Batch up to **100 queries** per run, each returning up to **30 ranked results** — hundreds to thousands of rows per run, with configurable concurrency to control speed.
**How do I export the results to CSV or JSON?**
Run the Actor, then export the dataset as **CSV, JSON, Excel or XML** from the Apify console, or pull it live through the Apify API / MCP.
**Can I search in other languages and regions?**
Yes. Set the **Region / language** field, e.g. `uk-en`, `de-de`, `fr-fr`, `es-es`.
**Is it legal to use?**
The Actor returns publicly available search results. You are responsible for using the data in compliance with the source engines' terms and applicable laws. Use it for legitimate research, grounding and automation.
**Can an AI agent call this directly?**
Yes — that's the primary design target. Because it's pay-per-event, an agent can discover and call it autonomously through the **Apify MCP server**, paying one charge per returned result. Wire it into Claude, Cursor, or any MCP client.
### 🔗 More AI, research & intelligence Actors by logiover
Building an agent or research pipeline? Pair AI Web Search with the rest of the AI & data-intelligence suite:
| Actor | What it does |
|---|---|
| [AI Deep Research](https://apify.com/logiover/ai-deep-research) | Multi-step autonomous research with cited findings |
| [AI Web Extract](https://apify.com/logiover/ai-web-extract) | Turn any URL into clean structured data / Markdown |
| [AI Citation Source Finder](https://apify.com/logiover/ai-citation-source-finder) | Find citable sources to ground LLM answers |
| [Company Deep Research Scraper](https://apify.com/logiover/company-deep-research-scraper) | Build a full company dossier from the open web |
| [News Intelligence Scraper](https://apify.com/logiover/news-intelligence-scraper) | Multi-source news monitoring for agents |
| [Google News Scraper](https://apify.com/logiover/google-news-scraper) | Fresh headlines & articles by query |
| [SERP Keyword Research](https://apify.com/logiover/serp-keyword-research) | Keyword ideas & SERP data for SEO |
| [Semantic Scholar Research Scraper](https://apify.com/logiover/semantic-scholar-research-scraper) | Academic papers & citations |
| [arXiv Paper Scraper](https://apify.com/logiover/arxiv-paper-scraper) | Preprints & research metadata |
| [GitHub Repository Scraper](https://apify.com/logiover/github-repository-scraper) | Repo metadata & code intelligence |
| [npm Package Intelligence Scraper](https://apify.com/logiover/npm-package-intelligence-scraper) | Package stats & dependency data |
| [CVE Security Advisory Monitor](https://apify.com/logiover/cve-security-advisory-monitor) | Track new vulnerabilities for agents |
👉 Browse all **[logiover scrapers on Apify Store](https://apify.com/logiover)** — 180+ actors across real estate, jobs, crypto, social media & B2B data.
### ⏰ Scheduling & integration
Schedule this Actor on Apify to refresh a research corpus or monitor rankings on any cadence. Export results to JSON, CSV or Excel, sync to **Google Sheets**, or push to your database, vector store, BI tools and **webhooks** through the Apify API. Connect it to **Make, n8n or Zapier** to build automated grounding and research pipelines — or expose it as an **MCP tool** so an AI agent can call it live.
### ⭐ Support & feedback
Found a bug or need an extra field (more engines, different content extraction)? Open an issue on the **Issues** tab — response is usually fast. If this Actor saves you time, a **★★★★★ review** on the Store page genuinely helps and is hugely appreciated. 🙏
### ⚖️ Legal
This Actor returns only publicly available search results and page content, and is intended for legitimate research, grounding, analytics and automation use. You are responsible for complying with the source engines' terms of service and any applicable laws.
***
### 📝 Changelog
#### 2026-07-06
- ✨ README overhaul: badge row, ready-to-run example scenarios, full field reference, richer FAQ (API alternative, keyless/no-browser, CSV/JSON export, how much data, legality) and the AI-research suite cross-links.
#### 1.0 (2026-07-04)
- Initial release: keyless live web search for AI agents and RAG.
- Dual engine: DuckDuckGo HTML primary, Bing automatic fallback for resilience.
- Clean ranked results per query: title, URL, display URL, snippet, source domain.
- Optional `includeContent` — attaches each result page's main content as clean Markdown for grounding.
- Region/language and safe-search controls; batch queries with configurable concurrency.
- Keyless; Apify datacenter proxy by default (RESIDENTIAL opt-in).
- Pay-per-event pricing: one charge per returned result. Agent-first, works as an MCP tool.
# Actor input Schema
## `queries` (type: `array`):
One or more search queries, e.g. `what is the model context protocol`. Batch up to 100.
## `query` (type: `string`):
A single search query. Use this or the queries list above.
## `maxResults` (type: `integer`):
How many ranked results to return per query (1–30).
## `includeContent` (type: `boolean`):
Fetch each result page and attach its main content as clean Markdown. Great for grounding, but slower and adds one fetch per result.
## `region` (type: `string`):
Search region and language code, e.g. `us-en`, `uk-en`, `de-de`, `fr-fr`.
## `safeSearch` (type: `boolean`):
Filter explicit results.
## `concurrency` (type: `integer`):
How many queries to run in parallel.
## `useApifyProxy` (type: `boolean`):
Route requests through Apify datacenter proxy. Recommended to avoid per-IP rate limits.
## `proxyGroups` (type: `array`):
Override proxy group, e.g. `RESIDENTIAL`. Leave empty for datacenter (AUTO).
## Actor input object example
```json
{
"queries": [
"what is the model context protocol"
],
"query": "best open source vector databases 2026",
"maxResults": 10,
"includeContent": false,
"region": "us-en",
"safeSearch": true,
"concurrency": 3,
"useApifyProxy": true,
"proxyGroups": []
}
```
# Actor output Schema
## `results` (type: `string`):
Full dataset of ranked results. One row = one result.
# 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 = {
"queries": [
"what is the model context protocol"
],
"maxResults": 10,
"includeContent": false,
"region": "us-en",
"safeSearch": true,
"concurrency": 3,
"useApifyProxy": true
};
// Run the Actor and wait for it to finish
const run = await client.actor("logiover/ai-web-search").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 = {
"queries": ["what is the model context protocol"],
"maxResults": 10,
"includeContent": False,
"region": "us-en",
"safeSearch": True,
"concurrency": 3,
"useApifyProxy": True,
}
# Run the Actor and wait for it to finish
run = client.actor("logiover/ai-web-search").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 '{
"queries": [
"what is the model context protocol"
],
"maxResults": 10,
"includeContent": false,
"region": "us-en",
"safeSearch": true,
"concurrency": 3,
"useApifyProxy": true
}' |
apify call logiover/ai-web-search --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=logiover/ai-web-search",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "AI Web Search — Live SERP API for Agents (Tavily Alternative)",
"description": "Keyless live web search for AI agents and RAG. Send a query, get clean ranked results (title, URL, snippet) from DuckDuckGo + Bing, with optional page content as Markdown. A Tavily / Exa / Brave Search alternative. No API key.",
"version": "1.0",
"x-build-id": "teoo69dFk8qngLDsd"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/logiover~ai-web-search/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-logiover-ai-web-search",
"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/logiover~ai-web-search/runs": {
"post": {
"operationId": "runs-sync-logiover-ai-web-search",
"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/logiover~ai-web-search/run-sync": {
"post": {
"operationId": "run-sync-logiover-ai-web-search",
"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": {
"queries": {
"title": "Search queries",
"type": "array",
"description": "One or more search queries, e.g. `what is the model context protocol`. Batch up to 100.",
"items": {
"type": "string"
},
"default": []
},
"query": {
"title": "Single query",
"type": "string",
"description": "A single search query. Use this or the queries list above."
},
"maxResults": {
"title": "Max results per query",
"minimum": 1,
"maximum": 30,
"type": "integer",
"description": "How many ranked results to return per query (1–30).",
"default": 10
},
"includeContent": {
"title": "Include page content (Markdown)",
"type": "boolean",
"description": "Fetch each result page and attach its main content as clean Markdown. Great for grounding, but slower and adds one fetch per result.",
"default": false
},
"region": {
"title": "Region / language",
"type": "string",
"description": "Search region and language code, e.g. `us-en`, `uk-en`, `de-de`, `fr-fr`.",
"default": "us-en"
},
"safeSearch": {
"title": "Safe search",
"type": "boolean",
"description": "Filter explicit results.",
"default": true
},
"concurrency": {
"title": "Concurrency",
"minimum": 1,
"maximum": 10,
"type": "integer",
"description": "How many queries to run in parallel.",
"default": 3
},
"useApifyProxy": {
"title": "Use Apify datacenter proxy",
"type": "boolean",
"description": "Route requests through Apify datacenter proxy. Recommended to avoid per-IP rate limits.",
"default": true
},
"proxyGroups": {
"title": "Proxy groups (advanced)",
"type": "array",
"description": "Override proxy group, e.g. `RESIDENTIAL`. Leave empty for datacenter (AUTO).",
"items": {
"type": "string"
},
"default": []
}
}
},
"runsResponseSchema": {
"type": "object",
"properties": {
"data": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"actId": {
"type": "string"
},
"userId": {
"type": "string"
},
"startedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"finishedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"status": {
"type": "string",
"example": "READY"
},
"meta": {
"type": "object",
"properties": {
"origin": {
"type": "string",
"example": "API"
},
"userAgent": {
"type": "string"
}
}
},
"stats": {
"type": "object",
"properties": {
"inputBodyLen": {
"type": "integer",
"example": 2000
},
"rebootCount": {
"type": "integer",
"example": 0
},
"restartCount": {
"type": "integer",
"example": 0
},
"resurrectCount": {
"type": "integer",
"example": 0
},
"computeUnits": {
"type": "integer",
"example": 0
}
}
},
"options": {
"type": "object",
"properties": {
"build": {
"type": "string",
"example": "latest"
},
"timeoutSecs": {
"type": "integer",
"example": 300
},
"memoryMbytes": {
"type": "integer",
"example": 1024
},
"diskMbytes": {
"type": "integer",
"example": 2048
}
}
},
"buildId": {
"type": "string"
},
"defaultKeyValueStoreId": {
"type": "string"
},
"defaultDatasetId": {
"type": "string"
},
"defaultRequestQueueId": {
"type": "string"
},
"buildNumber": {
"type": "string",
"example": "1.0.0"
},
"containerUrl": {
"type": "string"
},
"usage": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "integer",
"example": 1
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
},
"usageTotalUsd": {
"type": "number",
"example": 0.00005
},
"usageUsd": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "number",
"example": 0.00005
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
}
}
}
}
}
}
}
}
```