# BORME Corporate Acts Scraper (`automation-lab/borme-corporate-acts-scraper`) Actor

Scrape official Spanish BORME corporate acts, appointments, dissolutions, filings, and company-change notices from BOE gazette pages.

- **URL**: https://apify.com/automation-lab/borme-corporate-acts-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## BORME Corporate Acts Scraper 🇪🇸

Scrape official Spanish BORME corporate acts from BOE Mercantile Registry Gazette pages.

Use this actor to monitor company appointments, resignations, dissolutions, capital changes, filings, and official company-change notices published in the **Boletín Oficial del Registro Mercantil (BORME)**.

The actor reads public BOE/BORME daily pages and official XML notice documents, then returns structured records ready for compliance, KYB, legal, credit-risk, and sales operations workflows.

---

### What does BORME Corporate Acts Scraper do?

BORME Corporate Acts Scraper extracts corporate act announcements from Spain's official mercantile registry gazette.

It can:

- 📅 Scan one BORME issue date or a date range
- 🔗 Accept official BORME daily, TXT, or XML URLs
- 🏢 Extract company names and announcement numbers
- 📄 Capture full official notice text
- 🧾 Return issue number, section, province, XML URL, and PDF URL
- 🔎 Filter by section, province, company name, or act text
- ✅ Skip missing weekend or future issue dates gracefully

---

### Who is it for?

#### KYB and compliance teams

Track changes to Spanish companies during onboarding, periodic reviews, and sanctions or adverse-change monitoring.

#### Legal researchers

Collect official mercantile registry notices for due diligence, litigation support, and entity-history analysis.

#### Credit-risk analysts

Monitor dissolutions, appointments, management changes, capital events, and registry signals that may affect counterparty risk.

#### Sales and RevOps teams

Find company lifecycle events that can trigger outreach, vendor changes, decision-maker updates, or territory research.

#### Data teams

Feed official Spanish registry-gazette records into warehouses, alerts, enrichment jobs, or internal search indexes.

---

### Why use this scraper?

BORME pages are public but not optimized for high-volume monitoring.

This actor turns daily gazette pages into normalized JSON records with official evidence links.

Benefits:

- Official public source from BOE/BORME
- No login or private account required
- HTTP-first implementation for low cost and reliability
- Full text captured from official XML when available
- Filters designed around compliance and monitoring workflows
- Pay-per-result pricing so small monitoring jobs stay inexpensive

---

### What BORME data can I extract?

| Field | Description |
| --- | --- |
| `date` | BORME issue date |
| `issueNumber` | Official BORME issue number |
| `section` | Full official section label |
| `sectionCode` | BORME section code such as A, B, or C |
| `province` | Province/title from the official XML document |
| `companyName` | Company or entity named in the announcement |
| `actType` | Parsed high-level act labels from the notice text |
| `noticeTitle` | Official article line including announcement number |
| `noticeText` | Full official text for the corporate act |
| `announcementNumber` | BORME announcement/article number |
| `sourceUrl` | Official BOE/BORME TXT page |
| `pdfUrl` | Official PDF document URL |
| `xmlUrl` | Official XML document URL |
| `publishedAt` | Publication date from official metadata |
| `scrapedAt` | Timestamp when the actor saved the record |

---

### How much does it cost to scrape BORME corporate acts?

This actor uses pay-per-event pricing.

You pay a small start fee for each run and a per-item fee for each saved corporate act.

Typical cost depends on:

- number of issue dates scanned
- BORME sections selected
- province filters
- company or act-type filters
- `maxItems` limit

For cheap test runs, keep `maxItems` at 25-100 and scan one date.

For monitoring, schedule a daily run for the latest BORME issue and export only new records.

---

### How to use BORME Corporate Acts Scraper

1. Open the actor on Apify.
2. Enter `startDate` and optional `endDate` in `YYYY-MM-DD` format.
3. Optionally add official BORME URLs in `startUrls`.
4. Choose BORME sections such as `A` for company acts.
5. Add `province`, `companyQuery`, or `actTypeQuery` filters if needed.
6. Set `maxItems`.
7. Run the actor.
8. Download JSON, CSV, Excel, XML, or connect the dataset to your workflow.

---

### Input example

```json
{
  "startDate": "2026-07-03",
  "endDate": "2026-07-03",
  "sections": ["A"],
  "province": "MADRID",
  "actTypeQuery": "Nombramientos",
  "maxItems": 100
}
````

***

### Start URL example

You can also pass official BOE/BORME links directly:

```json
{
  "startUrls": [
    { "url": "https://www.boe.es/borme/dias/2026/07/03/" },
    { "url": "https://www.boe.es/diario_borme/xml.php?id=BORME-A-2026-126-28" }
  ],
  "sections": ["A"],
  "maxItems": 250
}
```

***

### Output example

```json
{
  "date": "2026-07-03",
  "issueNumber": "126",
  "section": "SECCIÓN PRIMERA. Empresarios. Actos inscritos",
  "sectionCode": "A",
  "province": "MADRID",
  "companyName": "DELINEXT ESPAÑA ECOMMERCE LOGISTICS SL",
  "actType": "Nombramientos",
  "noticeTitle": "314779 - DELNEXT ESPAÑA ECOMMERCE LOGISTICS SL.",
  "noticeText": "Nombramientos. Consejero: ... Datos registrales ...",
  "announcementNumber": "314779",
  "sourceUrl": "https://www.boe.es/diario_borme/txt.php?id=BORME-A-2026-126-28",
  "pdfUrl": "https://www.boe.es/borme/dias/2026/07/03/pdfs/BORME-A-2026-126-28.pdf",
  "xmlUrl": "https://www.boe.es/diario_borme/xml.php?id=BORME-A-2026-126-28",
  "publishedAt": "2026-07-03",
  "scrapedAt": "2026-07-06T00:00:00.000Z"
}
```

***

### BORME sections

The actor supports filtering by BORME section code.

Common values:

- `A` — Empresarios / actos inscritos
- `B` — Other mercantile registry acts where present
- `C` — Anuncios particulares and related notices

Leave `sections` empty to keep all discovered sections.

***

### Province and company filters

Use `province` when you need one registry territory such as:

- MADRID
- BARCELONA
- VALENCIA
- SEVILLA
- MÁLAGA

Use `companyQuery` to monitor one company or a family of company names.

The filters are case-insensitive substring filters.

***

### Act-type monitoring ideas

Useful `actTypeQuery` examples include:

- `Nombramientos`
- `Ceses/Dimisiones`
- `Disolución`
- `Ampliación de capital`
- `Revocaciones`
- `Modificaciones estatutarias`
- `Declaración de unipersonalidad`

Because BORME notice wording varies, you can also search broader terms in the full notice text.

***

### Tips for reliable runs

- Start with one date and a low `maxItems` value.
- Use section `A` for company act monitoring.
- Use `province` to reduce noise for regional workflows.
- Use `companyQuery` for recurring entity watchlists.
- Missing BORME dates can return 404; the actor logs and skips them.
- Use official daily URLs when you need exact issue reproducibility.

***

### Integrations

You can integrate the actor with:

- Google Sheets for daily corporate-change lists
- Slack alerts for watched companies
- Airtable or Notion for legal research queues
- BigQuery, Snowflake, or Postgres for registry-event history
- CRM enrichment workflows for sales triggers
- Compliance case-management systems
- Apify webhooks for daily monitoring automation

***

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/borme-corporate-acts-scraper').call({
  startDate: '2026-07-03',
  endDate: '2026-07-03',
  sections: ['A'],
  province: 'MADRID',
  maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/borme-corporate-acts-scraper').call(run_input={
    'startDate': '2026-07-03',
    'endDate': '2026-07-03',
    'sections': ['A'],
    'province': 'MADRID',
    'maxItems': 100,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~borme-corporate-acts-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startDate":"2026-07-03","sections":["A"],"province":"MADRID","maxItems":100}'
```

***

### MCP integration

Use this actor from Claude Desktop, Claude Code, or other MCP clients through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/borme-corporate-acts-scraper
```

Claude Code setup:

```bash
claude mcp add --transport http apify-borme "https://mcp.apify.com/?tools=automation-lab/borme-corporate-acts-scraper"
```

Claude Desktop JSON config example:

```json
{
  "mcpServers": {
    "apify-borme": {
      "url": "https://mcp.apify.com/?tools=automation-lab/borme-corporate-acts-scraper"
    }
  }
}
```

Example prompts:

- "Scrape BORME corporate acts for Madrid on 2026-07-03 and summarize appointments."
- "Find BORME notices mentioning dissolutions in section A for the latest issue URL."
- "Monitor this BORME date range and return companies with management changes."

***

### Scheduling daily BORME monitoring

Create an Apify task with yesterday's or the latest known BORME date and run it every weekday.

Then add a webhook that sends new dataset items to your database, Slack, or compliance system.

For high-signal alerts, combine:

- `sections: ["A"]`
- target `province`
- `actTypeQuery`
- moderate `maxItems`

***

### Data quality notes

The actor preserves official text from BOE/BORME XML documents.

Company names and announcement numbers are parsed from official article lines.

`actType` is a convenience summary parsed from notice text. For legal use, keep the full `noticeText`, `sourceUrl`, `xmlUrl`, and `pdfUrl` as the official evidence fields.

***

### Legality

BORME pages are public official government pages.

You are responsible for using extracted data lawfully and in line with applicable privacy, database, and compliance rules.

For regulated workflows, keep official source links in your audit trail and consult legal counsel about your use case.

***

### Related scrapers

Explore related automation-lab actors on Apify:

- https://apify.com/automation-lab/company-data-scraper
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/google-search-results-scraper

***

### FAQ

#### Can I scrape only one company?

Yes. Set `companyQuery` to the company-name substring you want to monitor.

#### Why did a date return no records?

The BORME issue may not exist for weekends, holidays, future dates, or unavailable publication days. The actor skips 404 dates instead of failing the whole run.

#### Does the actor download PDFs?

No. It extracts the official PDF URL and XML text. This keeps runs fast and low cost.

#### Can I monitor appointments only?

Yes. Use `actTypeQuery: "Nombramientos"` and section `A`.

#### Can I use this for compliance alerts?

Yes. The actor is designed for KYB, legal monitoring, and official evidence workflows, but you should validate alert rules for your organization.

***

### Support

If you need a field added or a BORME page type supported, open an issue on the actor page with an example official URL and expected output.

# Actor input Schema

## `startDate` (type: `string`):

First BORME issue date to scan in YYYY-MM-DD format. Weekends or missing/future dates are skipped gracefully.

## `endDate` (type: `string`):

Last BORME issue date to scan in YYYY-MM-DD format. Leave empty to scan only the start date.

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

Optional BOE/BORME daily pages, txt.php notice links, or xml.php notice links to scrape. Use this when you already know the official source URL.

## `sections` (type: `array`):

Keep only these BORME section codes. A = Empresarios / actos inscritos, B = otros actos, C = anuncios particulares. Empty means all sections.

## `province` (type: `string`):

Optional case-insensitive province filter, e.g. MADRID, BARCELONA, VALENCIA.

## `companyQuery` (type: `string`):

Optional case-insensitive company-name substring filter.

## `actTypeQuery` (type: `string`):

Optional case-insensitive text filter for act categories such as Nombramientos, Ceses/Dimisiones, Disolución, or Ampliación de capital.

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

Maximum dataset records to save. Use a low number for test runs and a larger number for monitoring workflows.

## Actor input object example

```json
{
  "startDate": "2026-07-03",
  "endDate": "2026-07-03",
  "startUrls": [
    {
      "url": "https://www.boe.es/borme/dias/2026/07/03/"
    }
  ],
  "sections": [
    "A"
  ],
  "province": "MADRID",
  "actTypeQuery": "Nombramientos",
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (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 = {
    "startDate": "2026-07-03",
    "endDate": "2026-07-03",
    "startUrls": [
        {
            "url": "https://www.boe.es/borme/dias/2026/07/03/"
        }
    ],
    "sections": [
        "A"
    ],
    "province": "MADRID",
    "companyQuery": "",
    "actTypeQuery": "Nombramientos",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/borme-corporate-acts-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 = {
    "startDate": "2026-07-03",
    "endDate": "2026-07-03",
    "startUrls": [{ "url": "https://www.boe.es/borme/dias/2026/07/03/" }],
    "sections": ["A"],
    "province": "MADRID",
    "companyQuery": "",
    "actTypeQuery": "Nombramientos",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/borme-corporate-acts-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 '{
  "startDate": "2026-07-03",
  "endDate": "2026-07-03",
  "startUrls": [
    {
      "url": "https://www.boe.es/borme/dias/2026/07/03/"
    }
  ],
  "sections": [
    "A"
  ],
  "province": "MADRID",
  "companyQuery": "",
  "actTypeQuery": "Nombramientos",
  "maxItems": 20
}' |
apify call automation-lab/borme-corporate-acts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BORME Corporate Acts Scraper",
        "description": "Scrape official Spanish BORME corporate acts, appointments, dissolutions, filings, and company-change notices from BOE gazette pages.",
        "version": "0.1",
        "x-build-id": "eb95a93keUiFxBwFv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~borme-corporate-acts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-borme-corporate-acts-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/automation-lab~borme-corporate-acts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-borme-corporate-acts-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/automation-lab~borme-corporate-acts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-borme-corporate-acts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startDate": {
                        "title": "Start date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "First BORME issue date to scan in YYYY-MM-DD format. Weekends or missing/future dates are skipped gracefully."
                    },
                    "endDate": {
                        "title": "End date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Last BORME issue date to scan in YYYY-MM-DD format. Leave empty to scan only the start date."
                    },
                    "startUrls": {
                        "title": "BORME start URLs",
                        "type": "array",
                        "description": "Optional BOE/BORME daily pages, txt.php notice links, or xml.php notice links to scrape. Use this when you already know the official source URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "sections": {
                        "title": "BORME sections",
                        "type": "array",
                        "description": "Keep only these BORME section codes. A = Empresarios / actos inscritos, B = otros actos, C = anuncios particulares. Empty means all sections.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "A",
                                "B",
                                "C"
                            ]
                        }
                    },
                    "province": {
                        "title": "Province filter",
                        "type": "string",
                        "description": "Optional case-insensitive province filter, e.g. MADRID, BARCELONA, VALENCIA."
                    },
                    "companyQuery": {
                        "title": "Company name contains",
                        "type": "string",
                        "description": "Optional case-insensitive company-name substring filter."
                    },
                    "actTypeQuery": {
                        "title": "Act text/type contains",
                        "type": "string",
                        "description": "Optional case-insensitive text filter for act categories such as Nombramientos, Ceses/Dimisiones, Disolución, or Ampliación de capital."
                    },
                    "maxItems": {
                        "title": "Maximum corporate acts",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum dataset records to save. Use a low number for test runs and a larger number for monitoring workflows.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
