# Gowork Reviews Scraper (`reviewly/gowork-reviews-scraper`) Actor

Scrapes employee reviews from GoWork.fr with full pagination, date filtering, review cap, deduplication, and residential proxy support.

- **URL**: https://apify.com/reviewly/gowork-reviews-scraper.md
- **Developed by:** [Reviewly](https://apify.com/reviewly) (community)
- **Categories:** AI, Jobs, 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

## GoWork.fr Reviews Scraper — Extract Employee Reviews at Scale

**The fastest way to collect company reviews from [GoWork.fr](https://gowork.fr) — no API key, no manual copy-paste, no limits.**

Extract employee reviews, ratings, company metadata, and employer responses from any GoWork.fr company page in minutes. Perfect for HR analysts, researchers, reputation management agencies, and recruiters who need structured review data at scale.

- ✅ Scrapes reviews, ratings, replies, and company info in one run
- ✅ Filter by date or cap at a maximum number of reviews
- ✅ Uses residential proxies — built for reliability, not blocked by GoWork.fr
- ✅ Pay only for what you scrape (per-review pricing)

---

### 📌 What This Actor Does

GoWork.fr is one of France's leading employee review platforms, similar to Glassdoor. Companies accumulate hundreds or thousands of employee reviews that are invaluable for competitive intelligence, HR benchmarking, and reputation monitoring.

This Apify Actor automates the extraction of that data. You provide one or more GoWork.fr company URLs, and the Actor returns a clean, structured dataset containing every review — including the reviewer's role, their experience date, their rating, and any official company response.

**Who is this for?**

- **HR & Talent teams** benchmarking employer brand vs. competitors
- **Reputation management agencies** monitoring client profiles on GoWork
- **Recruiters** researching company culture before approaching candidates
- **Market researchers & analysts** studying employee sentiment trends
- **Developers** building HR dashboards or review aggregators

---

### ✨ Key Features

- **Multi-URL support** — scrape dozens of companies in a single run
- **Full pagination** — automatically navigates all review pages, not just the first
- **Date filtering** — set a `targetDate` to only collect recent reviews; stops pagination the moment it reaches older content (no wasted compute)
- **Review cap** — set `maxNumberOfReviews` to limit exactly how many reviews you collect per company
- **Employer replies included** — captures official company responses to reviews
- **Role extraction** — captures the reviewer's job role/position
- **Experience date** — includes both the review publication date and the date the employee actually worked there
- **Duplicate-safe** — built-in deduplication prevents the same review from appearing twice
- **Residential proxies** — runs through French residential IPs for high success rates
- **Exponential backoff** — automatically retries failed requests up to 10 times with smart delays, so temporary blocks don't kill your run
- **Only rated reviews** — filters out unrated posts automatically, so your dataset stays clean

---

### 🧠 Why This Actor is Different

Most scrapers break the moment a site updates its layout. This Actor reads GoWork.fr's internal Nuxt.js data payload directly — the same structured JSON the site uses to render the page — rather than brittle CSS selectors. That means:

- **Higher data fidelity** — you get the raw, structured data, not text scraped from HTML
- **Less breakage** — visual layout changes don't affect the data extraction layer
- **Richer fields** — fields like `role`, `happeningDate`, and `ratingDetails` are available because they exist in the payload, not just what's visible on screen

Other advantages:

| Feature | This Actor | Generic scrapers |
|---|---|---|
| Residential proxies (FR) | ✅ Built-in | ❌ Manual setup |
| Date boundary stopping | ✅ Stops mid-pagination | ❌ Scrapes all, then filters |
| Employer reply capture | ✅ | ❌ Often missed |
| Per-review pricing | ✅ Pay only for results | ❌ Fixed cost regardless |
| Exponential retry backoff | ✅ Up to 10 retries | ❌ Single attempt |

---

### ⚙️ Input Configuration

#### Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `startUrls` | array | ✅ Yes | — | List of GoWork.fr company review page URLs |
| `maxNumberOfReviews` | number | ❌ No | `0` (no limit) | Maximum reviews to collect per company. `0` means collect all. |
| `targetDate` | string | ❌ No | `null` | Stop collecting reviews older than this date. Format: `YYYY-MM-DD` |
| `proxyConfiguration` | object | ❌ No | `{}` | Proxy options (see below) |

#### `proxyConfiguration` Options

| Field | Type | Default | Description |
|---|---|---|---|
| `apifyProxyCountry` | string | `"FR"` | Country code for the residential proxy exit node. Keep `FR` for best results on GoWork.fr. |

#### Example Input

```json
{
  "startUrls": [
    { "url": "https://gowork.fr/shopadora-paris" },
  ],
  "maxNumberOfReviews": 200,
  "targetDate": "2024-01-01",
  "proxyConfiguration": {
    "apifyProxyCountry": "FR"
  }
}
````

#### Tips for Best Results

- **Use the `/avis` page URL** — the reviews tab URL (e.g., `https://gowork.fr/amazon-aubervilliers`) works best
- **Set `targetDate` for incremental runs** — run weekly with last week's date to collect only new reviews
- **Leave `maxNumberOfReviews` at `0`** if you want the full history of a company
- **Keep `apifyProxyCountry` as `FR`** — GoWork.fr is a French platform; French exit IPs get the best success rates

***

### 📤 Output Format

Each dataset record corresponds to one company and contains its metadata alongside all collected reviews.

#### Structure

```json
{
  "entity": {
    "keyword": "Amazon",
    "id": 12345,
    "slug": "amazon",
    "totalRating": 3.2,
    "totalRatedReviews": 312,
    "totalReviews": 418,
    "url": "https://gowork.fr/amazon-aubervilliers",
    "ratingDetails": [
      { "1": 45 },
      { "2": 38 },
      { "3": 72 },
      { "4": 89 },
      { "5": 68 }
    ]
  },
  "reviews": [
    {
      "title": "Good environment but management needs work",
      "reviewBody": "Good environment but management needs work. The team is great but decisions come from the top without transparency.",
      "author": {
        "userName": "WarehouseWorker92"
      },
      "dateCreated": "15-04-2024 00:00",
      "experienceDate": "01-01-2024 00:00",
      "reviewId": 987654,
      "url": "https://gowork.fr/amazon-aubervilliers/review/987654",
      "rating": 3,
      "role": "Préparateur de commandes",
      "replies": [
        {
          "id": 111222,
          "message": "Thank you for your feedback. We are continuously working to improve communication at all levels.",
          "replyDate": "20-04-2024 00:00",
          "author": {
            "userName": "AmazonRH"
          }
        }
      ]
    }
  ]
}
```

#### Field Reference

**`entity` object:**

| Field | Description |
|---|---|
| `keyword` | Company name as listed on GoWork.fr |
| `id` | GoWork internal company ID |
| `slug` | URL slug (e.g., `amazon`) |
| `totalRating` | Overall average rating (e.g., `3.2`) |
| `totalRatedReviews` | Number of reviews that include a star rating |
| `totalReviews` | Total posts including unrated ones |
| `url` | Canonical GoWork.fr URL for the company |
| `ratingDetails` | Breakdown of review counts per star score (1–5) |

**Each `review` object:**

| Field | Description |
|---|---|
| `title` | First 200 characters of the review body (auto-generated) |
| `reviewBody` | Full review text |
| `author.userName` | Reviewer's GoWork username/nickname |
| `dateCreated` | Date the review was published (`DD-MM-YYYY HH:mm`) |
| `experienceDate` | Date the employee actually worked at the company |
| `reviewId` | Unique GoWork review ID |
| `url` | Direct link to the review page |
| `rating` | Star rating (1–5) |
| `role` | Job title/role declared by the reviewer |
| `replies` | Array of employer responses (empty array if none) |

***

### ▶️ How to Use

#### Option 1 — Apify Console (No Code)

1. Open the Actor on [Apify Store](https://apify.com/store)
2. Click **Try for free**
3. In the **Input** tab, paste your GoWork.fr company URLs under `startUrls`
4. Optionally set `maxNumberOfReviews` or `targetDate`
5. Click **Start** and wait for the run to finish
6. Go to the **Dataset** tab to view, filter, and export your data (JSON, CSV, Excel)

#### Option 2 — Apify 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://gowork.fr/amazon-aubervilliers" 
      }
    ],
    "maxNumberOfReviews": 100,
    "targetDate": "2024-01-01"
  }'
```

#### Option 3 — Schedule for Automated Monitoring

1. Go to **Schedules** in your Apify account
2. Create a new schedule (e.g., every Monday at 8:00 AM)
3. Attach this Actor with your desired input
4. Connect the output dataset to a webhook or Google Sheets integration

***

### 📈 Use Cases

#### 1. Employer Brand Monitoring

Track how your company's reputation evolves on GoWork.fr month over month. Feed the data into a dashboard to visualize rating trends, sentiment shifts, and response rates.

#### 2. Competitive HR Intelligence

Scrape reviews for 10–20 competitors in your industry. Identify recurring complaints (management, salary, work-life balance) to sharpen your own EVP (employer value proposition).

#### 3. Recruiting Research

Before approaching candidates at a target company, understand the internal culture through employee reviews. Use the `role` field to filter feedback from specific job functions.

#### 4. Reputation Management Campaigns

For agencies managing client profiles, run weekly scrapes with `targetDate` set to the previous week. Alert clients to new negative reviews within hours of posting.

#### 5. Sentiment Analysis & NLP Pipelines

Export the `reviewBody` field to feed into sentiment analysis models, LLMs, or topic clustering tools to extract structured insights from unstructured employee feedback.

***

### 🛠️ Advanced Tips

#### Incremental Scraping (Recommended for Regular Runs)

Set `targetDate` to the date of your last scrape. The Actor will stop pagination the moment it hits reviews older than that date — saving compute time and cost.

```json
{
  "targetDate": "2025-05-01"
}
```

#### Scraping Multiple Companies Efficiently

Add all company URLs to `startUrls` in a single run. The Actor processes them sequentially, each with a fresh residential proxy, so you never get rate-limited across companies.

```json
{
  "startUrls": [
    { "url": "https://gowork.fr/shopadora-paris" },
    { "url": "https://gowork.fr/amazon-aubervilliers" },
  ]
}
```

#### Proxy Country

GoWork.fr is a French platform. Always keep `apifyProxyCountry` as `"FR"` (the default) for maximum reliability. Changing it to another country may increase block rates.

#### Controlling Costs

Use `maxNumberOfReviews` to control exactly how many reviews you pay for per company. For example, if you only need the 50 most recent reviews for a quick pulse check, set `"maxNumberOfReviews": 50`.

***

### ❓ FAQ / Troubleshooting

**Q: The run finished but the dataset is empty. What happened?**

The Actor may have failed to parse the page. This usually happens when GoWork.fr changes its Nuxt data structure. Check the run logs for `error while parsing nuxt payload`. If you see this, please open an issue (see Support below) with the company URL — this is typically a quick fix.

**Q: Some reviews are missing. Why?**

The Actor only collects reviews with a star rating (`rating > 0`). GoWork.fr allows users to post without giving a score; those posts are excluded to keep the dataset clean. The `totalReviews` field in `entity` may therefore be higher than the number of reviews in your dataset.

**Q: Can I scrape in languages other than French?**

GoWork.fr is a French platform, so almost all content is in French. The Actor collects whatever text is on the page — no translation is applied.

**Q: How does `targetDate` interact with `maxNumberOfReviews`?**

Both limits are applied simultaneously. The Actor stops as soon as either condition is met — whichever comes first.

**Q: Does the Actor handle anti-bot measures?**

Yes. It uses French residential proxies, real browser fingerprints via Impit (Chrome), and randomized delays between page requests (200–700ms). Failed requests are retried up to 10 times with exponential backoff.

**Q: Is this against GoWork.fr's Terms of Service?**

This Actor accesses publicly available data — the same reviews any visitor can read in their browser. Users are responsible for ensuring their use of scraped data complies with applicable laws and platform terms in their jurisdiction.

**Q: Can I export to Excel or Google Sheets?**

Yes. Once the run is complete, go to the Dataset tab in Apify and use the **Export** button to download CSV, JSON, Excel, or XML. You can also connect to Google Sheets via Apify's native integration.

***

### 📞 Support

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

- 📧 **Email:** <me@ahmedhrid.com>
- 🐛 **Report issues:** Use the **Issues** tab on the Actor's Apify Store page

Response time is typically within 24–48 hours on business days.

# Actor input Schema

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

One or more GoWork.fr company review page URLs (e.g. https://gowork.fr/shopadora-paris).

## `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 GoWork.fr.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://gowork.fr/shopadora-paris"
    }
  ],
  "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, rating, role, author, title, reviewBody, dateCreated, experienceDate, url, replies.

# 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://gowork.fr/shopadora-paris"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("reviewly/gowork-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://gowork.fr/shopadora-paris" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("reviewly/gowork-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://gowork.fr/shopadora-paris"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call reviewly/gowork-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gowork Reviews Scraper",
        "description": "Scrapes employee reviews from GoWork.fr with full pagination, date filtering, review cap, deduplication, and residential proxy support.",
        "version": "0.0",
        "x-build-id": "rs0mLxP4ECIM7rVSi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/reviewly~gowork-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-reviewly-gowork-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~gowork-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-reviewly-gowork-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~gowork-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-reviewly-gowork-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 GoWork.fr company review page URLs (e.g. https://gowork.fr/shopadora-paris).",
                        "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 GoWork.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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
