# OpinionAssurance Reviews Scraper (`reviewly/opinionassurance-reviews-scraper`) Actor

Scrape insurance reviews from opinion-assurances.fr ratings, replies, and reviewer details  with date filtering and residential proxies. No coding required.

- **URL**: https://apify.com/reviewly/opinionassurance-reviews-scraper.md
- **Developed by:** [Reviewly](https://apify.com/reviewly) (community)
- **Categories:** AI, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 record scrapeds

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

## Opinion Assurances Reviews Scraper — Extract Insurance Reviews at Scale

**Automatically collect every customer review from [opinion-assurances.fr](https://www.opinion-assurances.fr) — including ratings, reviewer details, insurer replies, and experience dates — ready for analysis in minutes.**

- No coding required — runs fully in the cloud on Apify
- Handles pagination, anti-bot protection, and insurer reply extraction automatically
- Filter by date or cap the number of reviews to scrape only what you need
- Structured JSON output, ready to plug into spreadsheets, dashboards, or CRMs

---

### 📌 What This Actor Does

Opinion-assurances.fr is France's leading dedicated insurance review platform, hosting thousands of verified customer reviews across hundreds of insurance brands. This Apify Actor scrapes those reviews programmatically, giving you clean, structured data without the manual copy-paste work.

**Who is it for?**

- **Insurance companies & brokers** monitoring their e-reputation and tracking competitor sentiment
- **Market researchers & analysts** studying customer satisfaction trends in the French insurance sector
- **Digital agencies** managing online reputation for insurance clients
- **Data engineers** building review aggregation pipelines or training NLP models

---

### ✨ Key Features

- **Full pagination** — automatically navigates all review pages, not just the first one
- **Insurer reply extraction** — captures the company's official response to each review
- **Date filtering** — only collect reviews published on or after a target date (perfect for incremental runs)
- **Review cap** — set a maximum number of reviews to keep runs fast and cost-efficient
- **Residential proxy support** — uses French residential proxies to bypass blocks reliably
- **Exponential backoff retries** — automatically retries failed requests up to 10 times without crashing
- **Structured output** — one dataset item per company, with full entity metadata and a reviews array
- **Pay-per-result billing** — you are only charged for reviews actually scraped

---

### 🧠 Why This Actor is Different

Most generic web scrapers break on opinion-assurances.fr because the site requires JavaScript rendering and actively blocks bots. This Actor:

- Uses **full Chrome browser impersonation** (`impit`) with authentic browser headers, making it indistinguishable from a real user
- Routes all requests through **French residential proxies** — the same country as the target site — dramatically reducing block rates
- **Retries with exponential backoff**: if a request fails, it waits longer on each attempt instead of hammering the server, which is what triggers permanent blocks
- Extracts **insurer replies** by visiting each review's individual page — something most scrapers skip entirely
- Outputs **normalized ISO 8601 dates** so you can filter and sort without any date parsing on your end

---

### ⚙️ Input Configuration

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `startUrls` | Array | ✅ Yes | — | One or more opinion-assurances.fr company page URLs |
| `maxNumberOfReviews` | Integer | No | `0` (no limit) | Max reviews to collect per company |
| `targetDate` | String (date) | No | — | Only collect reviews on or after this date (`YYYY-MM-DD`) |
| `proxyConfiguration` | Object | No | RESIDENTIAL / FR | Proxy settings (Apify Proxy recommended) |

#### Example Input (JSON)

```json
{
  "startUrls": [
    { "url": "https://www.opinion-assurances.fr/assureur-credit-agricole.html" },
    { "url": "https://www.opinion-assurances.fr/assureur-maif.html" }
  ],
  "maxNumberOfReviews": 200,
  "targetDate": "2024-01-01",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "FR"
  }
}
````

#### Tips for Best Results

- **Finding the right URL**: go to opinion-assurances.fr, search for an insurer, and copy the URL from your browser's address bar. It will look like `https://www.opinion-assurances.fr/assureur-[brand-name].html`.
- **For incremental monitoring**: set `targetDate` to the date of your last run. The scraper will stop as soon as it reaches older reviews, keeping costs low.
- **For a full historical export**: leave both `maxNumberOfReviews` and `targetDate` empty — the Actor will paginate through all available reviews.
- **Always use French residential proxies** (`apifyProxyCountry: "FR"`) for the best success rate on this site.

***

### 📤 Output Format

Each run produces one dataset item per company URL. The item contains two top-level keys: `entity` (company metadata) and `reviews` (array of review objects).

#### Sample Output

```json
{
  "entity": {
    "businessName": "Crédit Agricole Assurances",
    "score": 3.8,
    "totalNumberOfReviews": 1240,
    "ratings": {
      "one": 186,
      "two": 112,
      "three": 174,
      "four": 261,
      "five": 507
    },
    "businessUrl": "https://www.opinion-assurances.fr/assureur-credit-agricole.html"
  },
  "reviews": [
    {
      "reviewId": "12345",
      "title": "Très bonne expérience avec mon conseiller",
      "text": "Très bonne expérience avec mon conseiller",
      "rating": 5,
      "label": "Particulier",
      "consumerName": "Jean D.",
      "datetime": "2024-03-15T00:00:00.000Z",
      "dateOfExperience": "2024-02-10T00:00:00.000Z",
      "reviewUrl": "https://www.opinion-assurances.fr/avis-12345-credit-agricole.html",
      "reply": {
        "repliedBy": "crédit agricole assurances",
        "publishedDate": "2024-03-18T00:00:00.000Z",
        "message": "Merci pour votre témoignage, nous sommes ravis de votre satisfaction."
      }
    }
  ]
}
```

#### Field Reference

**`entity` object**

| Field | Type | Description |
|---|---|---|
| `businessName` | String | Official company name as listed on opinion-assurances.fr |
| `score` | Float | Overall average rating (1–5) |
| `totalNumberOfReviews` | Integer | Total number of reviews on the platform |
| `ratings` | Object | Count of reviews per star level (`one` through `five`) |
| `businessUrl` | String | The input URL for this company |

**`reviews` array items**

| Field | Type | Description |
|---|---|---|
| `reviewId` | String | Unique review identifier |
| `title` | String | Review title (first 200 characters of the review text) |
| `text` | String | Full review text |
| `rating` | Integer | Star rating given by the reviewer (1–5) |
| `label` | String | Reviewer category (e.g. "Particulier", "Professionnel") |
| `consumerName` | String | Reviewer's display name |
| `datetime` | String | Review publication date (ISO 8601) |
| `dateOfExperience` | String | Date of the insurance experience described (ISO 8601) |
| `reviewUrl` | String | Direct link to the full review page |
| `reply` | Object | `null` | Insurer's reply, or `null` if no reply was posted |

**`reply` object**

| Field | Type | Description |
|---|---|---|
| `repliedBy` | String | Name of the respondent (usually the insurer name) |
| `publishedDate` | String | Date the reply was published (ISO 8601) |
| `message` | String | Full text of the reply |

***

### ▶️ How to Use

#### Option 1: Run directly on Apify (recommended)

1. Click **Try for free** on this Actor's page
2. In the **Input** tab, paste one or more opinion-assurances.fr company URLs into `startUrls`
3. Optionally set `targetDate` and/or `maxNumberOfReviews`
4. Click **Start** and wait for the run to finish
5. Go to the **Dataset** tab to view or download your results (JSON, CSV, Excel, etc.)

#### Option 2: Trigger via API

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://www.opinion-assurances.fr/assureur-maif.html"}],
    "maxNumberOfReviews": 100,
    "targetDate": "2024-06-01"
  }'
```

#### Option 3: Schedule automated runs

Use Apify's **Schedules** feature to run this Actor automatically (e.g. every Monday morning) to keep your review data always up to date. Combine with `targetDate` set to the previous run date to collect only new reviews.

***

### 📈 Use Cases

#### 1. E-reputation monitoring

Set up a weekly scheduled run for your own brand to track new reviews and reply rates. Get alerted to drops in average rating before they affect your business.

#### 2. Competitive benchmarking

Scrape the top 10 insurers in your segment and compare their satisfaction scores, rating distributions, and response rates side by side.

#### 3. Lead generation for brokers

Identify insurers with consistently low ratings (dissatisfied customers) and use that as a signal for outreach — these customers are actively looking for alternatives.

#### 4. NLP & sentiment analysis training data

Build a labeled French-language dataset of insurance reviews for training sentiment classifiers or topic extraction models.

#### 5. Market research reports

Aggregate review volumes and scores over time to produce quarterly trend reports on customer satisfaction across the French insurance market.

***

### 🛠️ Advanced Tips

#### Incremental runs (avoid re-scraping old data)

Set `targetDate` to the date of your last run. The Actor stops paginating as soon as it reaches a review older than that date, so you only pay for new reviews.

#### Scraping multiple companies efficiently

Add all your target URLs to `startUrls` in a single run. Each company is processed sequentially with its own proxy session — more reliable than running separate jobs.

#### Adjusting proxy country

If you need to test or access the site from a different location, set `apifyProxyCountry` in the proxy configuration. For opinion-assurances.fr, `FR` always gives the best results.

#### Handling large catalogs

For insurers with thousands of reviews, leave `targetDate` and `maxNumberOfReviews` unset for the first (historical) run, then switch to incremental mode for all subsequent runs.

***

### ❓ FAQ & Troubleshooting

**Q: The run completed but I got fewer reviews than expected.**
The Actor applies the `maxNumberOfReviews` cap and the `targetDate` filter strictly. Check the run log — it prints the final `Reviews pushed` and `Reviews filtered` counts at the end. Also verify that the input URL is the correct company page (not a search results page).

**Q: The run failed with "got blocked" or returned empty results.**
This usually means the proxy configuration is not set to French residential proxies. Make sure `apifyProxyGroups` is `["RESIDENTIAL"]` and `apifyProxyCountry` is `"FR"`.

**Q: Some reviews have `reply: null`.**
That is expected — most reviews do not have an insurer reply. The Actor visits each review's individual page to check; if no reply exists, it stores `null`.

**Q: Can I scrape all insurers at once?**
Yes — simply add as many URLs as you want to `startUrls`. There is no hard limit. For very large lists, consider splitting into multiple Actor runs to stay within memory limits.

**Q: How often is the data updated on opinion-assurances.fr?**
The source site updates in real time as users post reviews. Run this Actor on a schedule to keep your dataset current.

**Q: Does the Actor work with the Apify free plan?**
Yes. The free plan includes $5 of monthly platform credits. A single run collecting ~500 reviews typically costs less than $0.50 in compute + proxy usage.

***

### 📞 Support

Have a question, found a bug, or need a custom feature?

- **Email**: <me@ahmedhrid.com>
- **Issues**: use the Issues tab on this Actor's Apify Store page

# Actor input Schema

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

One or more opinion-assurances.fr company page URLs (e.g. https://www.opinion-assurances.fr/assureur-acbs.html).

## `maxNumberOfReviews` (type: `integer`):

Maximum number of reviews to collect per company. Set to 0 (or leave empty) for no limit.

## `targetDate` (type: `string`):

Only collect reviews published on or after this date. Leave empty to collect all reviews.

## `proxyConfiguration` (type: `object`):

Proxy servers used to avoid rate limiting and blocks. French residential proxies are recommended for opinion-assurances.fr.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.opinion-assurances.fr/assureur-acbs.html"
    }
  ],
  "maxNumberOfReviews": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Each item contains an `entity` object and a `reviews` array. Review fields: reviewId, title, text, rating, label, consumerName, datetime, dateOfExperience, reviewUrl, reply.

# 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.opinion-assurances.fr/assureur-acbs.html"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("reviewly/opinionassurance-reviews-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 = {
    "startUrls": [{ "url": "https://www.opinion-assurances.fr/assureur-acbs.html" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("reviewly/opinionassurance-reviews-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.opinion-assurances.fr/assureur-acbs.html"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call reviewly/opinionassurance-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpinionAssurance Reviews Scraper",
        "description": "Scrape insurance reviews from opinion-assurances.fr ratings, replies, and reviewer details  with date filtering and residential proxies. No coding required.",
        "version": "0.0",
        "x-build-id": "hQIMdDao3QxnM75yi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/reviewly~opinionassurance-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-reviewly-opinionassurance-reviews-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/reviewly~opinionassurance-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-reviewly-opinionassurance-reviews-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/reviewly~opinionassurance-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-reviewly-opinionassurance-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Company Review URLs",
                        "type": "array",
                        "description": "One or more opinion-assurances.fr company page URLs (e.g. https://www.opinion-assurances.fr/assureur-acbs.html).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxNumberOfReviews": {
                        "title": "Max reviews per company",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect per company. Set to 0 (or leave empty) for no limit.",
                        "default": 0
                    },
                    "targetDate": {
                        "title": "Filter reviews on or after date",
                        "type": "string",
                        "description": "Only collect reviews published on or after this date. Leave empty to collect all reviews."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy servers used to avoid rate limiting and blocks. French residential proxies are recommended for opinion-assurances.fr.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
