# E-Commerce Product Description Rewriter (`trovevault/ecommerce-product-description-rewriter`) Actor

Scrapes product descriptions from any e-commerce URL, grades them against SEO best practices (0–100), then rewrites them with AI to eliminate duplicate content penalties and improve search rankings.

- **URL**: https://apify.com/trovevault/ecommerce-product-description-rewriter.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** AI, E-commerce, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 product descriptions

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## E-Commerce Product Description Rewriter

Rewrite product descriptions for SEO in seconds — no copywriter needed. The E-Commerce Product Description Rewriter scrapes any product page, grades the description against 5 SEO dimensions, and rewrites it with AI to eliminate duplicate content penalties and improve organic rankings. Built for e-commerce teams, SEO agencies, and store owners on Shopify, WooCommerce, Magento, BigCommerce, and beyond.

---

### What does the E-Commerce Product Description Rewriter do?

The E-Commerce Product Description Rewriter visits any product URL, extracts the existing description, scores it from 0 to 100 using an AI SEO grader, and generates a new version optimized for search — with a before/after score comparison so you know exactly how much it improved.

**Core capabilities:**

- 🔍 Scrapes product descriptions from any e-commerce platform — Shopify, WooCommerce, Magento, BigCommerce, and custom stores
- 📊 Grades descriptions on 5 SEO dimensions: word count, benefit focus, uniqueness, keyword use, and readability
- ✍️ Rewrites descriptions using LLaMA 3.3 70B via Groq — benefit-first, no boilerplate
- 🎯 Naturally integrates your target keyword exactly twice (start + end) to avoid stuffing
- 🌍 Outputs in 7 languages: English, Spanish, French, German, Portuguese, Italian, Dutch
- 🎨 4 writing tones: Professional, Casual, Enthusiastic, Minimalist

---

### What data does the E-Commerce Product Description Rewriter output?

| Rewrite output | SEO scoring | Meta |
|---|---|---|
| 📝 Original description | 📊 Original SEO score (0–100) | 🔗 Product URL |
| ✍️ Rewritten description | 📈 Rewritten SEO score (0–100) | 🏷️ Product name |
| 🔢 Word count | ➕ Score improvement (delta) | 📅 Scraped timestamp |
| 🎯 Target keyword used | 📋 Score breakdown (5 dimensions) | 🎨 Tone used |
| 🌍 Output language | ⚠️ SEO issues found | ✅ SEO improvements made |

---

### Can I use the E-Commerce Product Description Rewriter on Shopify, WooCommerce, or Magento?

Yes. The E-Commerce Product Description Rewriter works on any publicly accessible product page. It covers Shopify, WooCommerce, Magento, BigCommerce, Prestashop, and custom-built stores. No platform-specific configuration is needed — just paste the product URL and start.

Supported platforms include: Shopify, WooCommerce, Magento, BigCommerce, Prestashop, OpenCart, Squarespace Commerce, Wix Stores, Salesforce Commerce Cloud, SAP Commerce Cloud, and any store with standard HTML product pages.

---

### How does the E-Commerce Product Description Rewriter work?

**The Process:**

1. **Input your product URLs** — paste one or more product page URLs into the `startUrls` field
2. **The actor scrapes the page** — Playwright renders the JS, then a multi-selector scraper extracts the product name and description
3. **SEO scoring (before)** — the original description is graded on 5 dimensions: word count, benefit focus, uniqueness, keyword use, and readability
4. **AI rewrite** — LLaMA 3.3 70B rewrites the description in your chosen tone and language, leading with the strongest customer benefit and integrating your keyword naturally
5. **SEO scoring (after)** — the rewritten version is graded using the same rubric so you can see the exact improvement
6. **Results saved** — all data is pushed to the Apify dataset: original, rewrite, scores, and breakdown

Think of it like having a senior SEO copywriter review and rewrite every product description on your store — automatically, at scale.

---

### Why use the E-Commerce Product Description Rewriter?

| Feature | Copywriting tools | E-Commerce Product Description Rewriter |
|---|---|---|
| Scrapes the page automatically | No — you paste the text manually | Yes — just add the URL |
| SEO grade before and after | No | Yes — 0–100 score with breakdown |
| Keyword integration | Manual | Automatic, exactly 2× to avoid stuffing |
| Multi-language output | Paid add-on | 7 languages included |
| No boilerplate phrases | Depends on the prompt | Enforced by the system prompt |
| Works at scale | Slow per-item | Processes multiple URLs in one run |
| API access | No | Yes — full Apify API |

---

### What can you do with rewritten descriptions?

**E-commerce store owners:**
Copy the rewritten descriptions directly into your CMS (Shopify admin, WooCommerce product editor, Magento backend). Schedule weekly runs to keep freshly launched products optimized without a copywriter on retainer.

**SEO agencies:**
Run the actor on a client's entire product catalog, export the dataset as CSV or JSON, and deliver a before/after SEO report with the score delta per product. Hourly scheduling is not needed — weekly or on-demand is enough for product content.

**Brand managers and marketplace sellers:**
Use the rewrite output for Amazon listings, Google Shopping descriptions, or any marketplace that penalizes duplicate manufacturer copy. The Minimalist tone works well for luxury positioning; Enthusiastic suits sports and tech SKUs.

**Product teams:**
Connect the actor output to n8n, Zapier, or Make to automatically push rewritten descriptions back into your product database or CMS on each run.

---

### How to use the E-Commerce Product Description Rewriter

1. **Open the actor** on Apify Store and click **Try for free**
2. **Add product URLs** — paste one or more product page URLs into the `startUrls` field
3. **Set your options:**
   - **Target keyword** — the SEO term you want to rank for (optional; AI chooses if left blank)
   - **Tone** — Professional, Casual, Enthusiastic, or Minimalist
   - **Target word count** — 150–250 is optimal for most product pages
   - **Language** — English, Spanish, French, German, Portuguese, Italian, or Dutch
   - **Max products** — limit how many URLs to process per run
4. **Click Start** — results appear in the dataset within 30–60 seconds per product
5. **Export results** — download as JSON, CSV, Excel, or connect via API

---

### ⬇️ Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `startUrls` | array | ✅ | — | Product page URLs to process |
| `targetKeyword` | string | ❌ | (auto) | SEO keyword to integrate into the rewrite |
| `tone` | string | ❌ | Professional | Writing tone: Professional, Casual, Enthusiastic, Minimalist |
| `targetWordCount` | integer | ❌ | 200 | Target word count for the rewrite (80–500) |
| `language` | string | ❌ | English | Output language for the rewritten description |
| `maxProducts` | integer | ❌ | 5 | Maximum number of product pages to process |

**Example input:**

```json
{
  "startUrls": [
    { "url": "https://www.allbirds.com/products/mens-tree-runners" }
  ],
  "targetKeyword": "men's running shoes",
  "tone": "Enthusiastic",
  "targetWordCount": 200,
  "language": "English",
  "maxProducts": 1
}
````

**Bulk run example:**

```json
{
  "startUrls": [
    { "url": "https://www.example.com/products/product-a" },
    { "url": "https://www.example.com/products/product-b" },
    { "url": "https://www.example.com/products/product-c" }
  ],
  "tone": "Professional",
  "targetWordCount": 180,
  "language": "Spanish",
  "maxProducts": 50
}
```

***

### ⬆️ Output

Results are saved to the Apify dataset. Each item represents one product page.

**Example output item:**

```json
{
  "url": "https://www.allbirds.com/products/mens-tree-runners",
  "productName": "Men's Tree Runners",
  "originalDescription": "The original description scraped from the page...",
  "originalSeoScore": 52,
  "originalSeoBreakdown": {
    "wordCount": 14,
    "benefitFocused": 10,
    "uniqueness": 12,
    "keywordUse": 8,
    "readability": 8
  },
  "originalSeoIssues": [
    "Description is too short — under 100 words",
    "Leads with product name instead of customer benefit",
    "Contains generic phrase 'premium quality'"
  ],
  "rewrittenDescription": "Every step forward feels lighter when your shoes are built from eucalyptus tree fiber...",
  "rewrittenSeoScore": 84,
  "rewrittenSeoBreakdown": {
    "wordCount": 20,
    "benefitFocused": 18,
    "uniqueness": 16,
    "keywordUse": 16,
    "readability": 14
  },
  "rewrittenSeoImprovements": [
    "Opens with a strong sensory customer benefit",
    "Men's running shoes integrated naturally near start and end",
    "No generic boilerplate phrases detected"
  ],
  "scoreImprovement": 32,
  "wordCount": 198,
  "targetKeyword": "men's running shoes",
  "tone": "Enthusiastic",
  "language": "English",
  "scrapedAt": "2026-03-30T20:00:00.000Z"
}
```

**Export formats:** JSON, CSV, Excel, XML, RSS — available from the dataset view or via the Apify API.

***

### Are there other tools in the Apify Store?

- 🛒 [E-Commerce Scraping Tool](https://apify.com/apify/e-commerce-scraping-tool) — scrape product data from any e-commerce site
- 💰 [Amazon Price Tracker](https://apify.com/apify/amazon-price-tracker) — monitor price changes on Amazon
- ⭐ [Review Scraper](https://apify.com/apify/review-scraper) — collect product reviews at scale
- 🔍 [Google Shopping Scraper](https://apify.com/apify/google-shopping-scraper) — scrape Google Shopping results

***

### FAQ

**Can I use the E-Commerce Product Description Rewriter on any e-commerce site?**
Yes. The actor works on any publicly accessible product page — Shopify, WooCommerce, Magento, BigCommerce, Prestashop, and custom HTML stores. If the description is visible in the browser, the actor can scrape and rewrite it.

**How many products can I rewrite per run?**
As many as you need. Set `maxProducts` to control the batch size. For testing, start with 1–5. For a full catalog refresh, set it to 100+ and let the run complete. There is no hard cap.

**What is the SEO score and how is it calculated?**
The score goes from 0 to 100 and is graded on 5 dimensions worth 20 points each: word count adequacy, benefit-focused language, uniqueness (no boilerplate), natural keyword use, and readability. The actor shows the score before and after the rewrite plus the delta so you can quantify the improvement.

**How often should I run the E-Commerce Product Description Rewriter?**
Run it when you launch new products, after a product line refresh, or on a monthly schedule for ongoing SEO maintenance. There is no need for daily runs — product descriptions change infrequently.

**Can I rewrite descriptions in languages other than English?**
Yes. The actor supports English, Spanish, French, German, Portuguese, Italian, and Dutch. The original description can be in any language — the rewrite will always output in your selected language.

**What if the actor can't find the description on a page?**
The scraper tries 15+ CSS selectors covering all major platforms, then falls back to the meta description and largest paragraph on the page. If no usable text is found, the URL is skipped and logged as a warning. You can retry with a direct product page URL (not a category or search page).

**Can I connect the output to my CMS or database automatically?**
Yes. Use the Apify API to fetch the dataset after each run, or connect via Zapier, Make, or n8n to push rewritten descriptions directly into Shopify, WooCommerce, or any CMS that has an API.

**Can I use the E-Commerce Product Description Rewriter with the Apify API?**
Yes. Every actor on Apify has a full REST API. You can trigger runs, pass input, and retrieve results programmatically. See the [Apify API documentation](https://docs.apify.com/api/v2) for details.

**Can I use the E-Commerce Product Description Rewriter through an MCP Server?**
Yes. Apify offers an MCP server that exposes all actors — including the E-Commerce Product Description Rewriter — to AI agents and tools that support the Model Context Protocol. This means you can trigger rewrites directly from Claude, Cursor, or any MCP-compatible client without leaving your workflow.

**Is scraping product descriptions legal?**
Scraping publicly visible product descriptions is generally considered legal in most jurisdictions, as confirmed by court rulings including hiQ v. LinkedIn. The actor only accesses data that is visible to any browser without authentication. Always review the terms of service of the specific site you are scraping, and use the data responsibly.

***

### Your feedback

Found a bug or a site the actor doesn't handle? Open an issue in the [Issues tab](https://apify.com/luispinto/ecommerce-product-description-rewriter/issues) — every report is reviewed.

# Actor input Schema

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

URLs of product pages to scrape and rewrite. Must be individual product pages — not category pages, homepages, or search results. Example: https://www.example.com/products/running-shoes

## `targetKeyword` (type: `string`):

The main SEO keyword to naturally integrate into the rewritten description. Example: 'waterproof hiking boots'. Leave empty to let the AI decide based on the product.

## `tone` (type: `string`):

The tone of the rewritten descriptions. Professional suits B2B and premium brands. Casual suits lifestyle and consumer brands. Enthusiastic suits sports and tech. Minimalist suits luxury and design brands.

## `targetWordCount` (type: `integer`):

Approximate word count for the rewritten description. 150–250 is optimal for most product pages. Higher counts suit complex or technical products. Lower counts suit minimalist store designs.

## `language` (type: `string`):

Language for the rewritten description. The original description is scraped in any language but the rewrite will be in the selected language.

## `maxProducts` (type: `integer`):

Maximum number of product pages to process. Keep low for testing, increase for batch runs.

## `datasetId` (type: `string`):

ID of an existing Apify dataset to push results into in addition to the default dataset. Useful for combining results from multiple runs or integrating with downstream actors.

## `runId` (type: `string`):

ID of a previous actor run to associate this run with. Used for chaining actors in multi-step pipelines.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.allbirds.com/products/mens-tree-runners"
    }
  ],
  "tone": "Professional",
  "targetWordCount": 200,
  "language": "English",
  "maxProducts": 5
}
```

# Actor output Schema

## `dataset` (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 = {
    "startUrls": [
        {
            "url": "https://www.allbirds.com/products/mens-tree-runners"
        }
    ],
    "targetKeyword": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/ecommerce-product-description-rewriter").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 = {
    "startUrls": [{ "url": "https://www.allbirds.com/products/mens-tree-runners" }],
    "targetKeyword": "",
}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/ecommerce-product-description-rewriter").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.allbirds.com/products/mens-tree-runners"
    }
  ],
  "targetKeyword": ""
}' |
apify call trovevault/ecommerce-product-description-rewriter --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trovevault/ecommerce-product-description-rewriter",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "E-Commerce Product Description Rewriter",
        "description": "Scrapes product descriptions from any e-commerce URL, grades them against SEO best practices (0–100), then rewrites them with AI to eliminate duplicate content penalties and improve search rankings.",
        "version": "0.1",
        "x-build-id": "0npWesedp1jCCEJkK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~ecommerce-product-description-rewriter/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-ecommerce-product-description-rewriter",
                "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/trovevault~ecommerce-product-description-rewriter/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-ecommerce-product-description-rewriter",
                "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/trovevault~ecommerce-product-description-rewriter/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-ecommerce-product-description-rewriter",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "URLs of product pages to scrape and rewrite. Must be individual product pages — not category pages, homepages, or search results. Example: https://www.example.com/products/running-shoes",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "targetKeyword": {
                        "title": "Target Keyword",
                        "type": "string",
                        "description": "The main SEO keyword to naturally integrate into the rewritten description. Example: 'waterproof hiking boots'. Leave empty to let the AI decide based on the product."
                    },
                    "tone": {
                        "title": "Writing Tone",
                        "enum": [
                            "Professional",
                            "Casual",
                            "Enthusiastic",
                            "Minimalist"
                        ],
                        "type": "string",
                        "description": "The tone of the rewritten descriptions. Professional suits B2B and premium brands. Casual suits lifestyle and consumer brands. Enthusiastic suits sports and tech. Minimalist suits luxury and design brands.",
                        "default": "Professional"
                    },
                    "targetWordCount": {
                        "title": "Target Word Count",
                        "minimum": 80,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Approximate word count for the rewritten description. 150–250 is optimal for most product pages. Higher counts suit complex or technical products. Lower counts suit minimalist store designs.",
                        "default": 200
                    },
                    "language": {
                        "title": "Output Language",
                        "enum": [
                            "English",
                            "Spanish",
                            "French",
                            "German",
                            "Portuguese",
                            "Italian",
                            "Dutch"
                        ],
                        "type": "string",
                        "description": "Language for the rewritten description. The original description is scraped in any language but the rewrite will be in the selected language.",
                        "default": "English"
                    },
                    "maxProducts": {
                        "title": "Max Products",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of product pages to process. Keep low for testing, increase for batch runs.",
                        "default": 5
                    },
                    "datasetId": {
                        "title": "Dataset ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify dataset to push results into in addition to the default dataset. Useful for combining results from multiple runs or integrating with downstream actors."
                    },
                    "runId": {
                        "title": "Run ID (optional)",
                        "type": "string",
                        "description": "ID of a previous actor run to associate this run with. Used for chaining actors in multi-step pipelines."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
