# SIMBAD Astronomical Objects Scraper (`parseforge/simbad-astronomical-objects-scraper`) Actor

Pull stars, galaxies, quasars, and nebulae from the SIMBAD database by object type, identifier, or custom ADQL query. Returns main identifier, RA and Dec, object type, spectral type, magnitudes, parallax, radial velocity, and cross identifiers. Good for observing plans and catalog work.

- **URL**: https://apify.com/parseforge/simbad-astronomical-objects-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🔭 SIMBAD Astronomical Objects Scraper

> 🚀 **Export astronomical objects in seconds.** Pull stars, galaxies, quasars, clusters, and nebulae from the SIMBAD database with coordinates, object type, magnitudes, parallax, radial velocity, and dozens of cross identifiers per object.

> 🕒 **Last updated:** 2026-06-05 · **📊 25 fields** per record · queries the full SIMBAD catalog of 19+ million objects · global all-sky coverage

SIMBAD (Set of Identifications, Measurements and Bibliography for Astronomical Data), maintained by the Centre de Données astronomiques de Strasbourg (CDS), is the reference database for objects beyond the Solar System. This Actor queries the official SIMBAD TAP service using ADQL and returns clean, structured records ready for analysis.

**Coverage:** stars, double and multiple stars, variable stars, white dwarfs, galaxies, quasars, active galactic nuclei, galaxy clusters, star clusters, globular clusters, planetary nebulae, supernova remnants, HII regions, and more. Each record carries equatorial coordinates in degrees, the object type, spectral and morphological types when known, optical and infrared magnitudes (U, B, V, R, G, J, H, K), parallax, radial velocity, redshift, proper motion, and the full list of cross identifiers (HD, HIP, Gaia, 2MASS, TYC, NGC, and many catalog designations).

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Astronomers and astrophysicists | Building target lists and observing plans |
| Data scientists and researchers | Cross matching catalogs by identifier |
| Educators and students | Teaching datasets and class projects |
| Planetarium and outreach teams | Populating sky atlases and visualizations |
| Amateur astronomers | Finding objects by type, position, or brightness |

### 📋 What the SIMBAD Astronomical Objects Scraper does

This Actor talks to the SIMBAD TAP sync endpoint and runs an ADQL query against the `basic` table joined with the `allfluxes` table. You can supply your own ADQL query for full control, or use the built in filters to select by object type, by text contained in the main identifier, and to require a measured V magnitude. For every returned object the Actor also fetches the complete list of cross identifiers from the `ident` table, so you get every catalog name an object is known by.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `adqlQuery` | string | Optional custom ADQL query. Overrides the filters when provided. |
| `objectType` | select | Filter by SIMBAD object type code (G, QSO, PM*, EB*, and more). |
| `nameContains` | string | Return only objects whose main identifier contains this text. |
| `requireMagnitude` | boolean | Keep only objects that have a measured V band magnitude. |
| `maxItems` | integer | Maximum number of objects to return. |

**Example 1 — default run (mixed object types):**
```json
{
  "maxItems": 10
}
````

**Example 2 — galaxies with a custom ADQL query:**

```json
{
  "adqlQuery": "SELECT TOP 50 b.oid, b.main_id, b.ra, b.dec, b.otype, b.otype_txt, b.sp_type, b.morph_type, b.plx_value, b.plx_err, b.rvz_radvel, b.rvz_redshift, b.pmra, b.pmdec, b.nbref, f.U, f.B, f.V, f.R, f.G, f.J, f.H, f.K FROM basic AS b LEFT JOIN allfluxes AS f ON b.oid = f.oidref WHERE b.otype = 'G' AND b.morph_type IS NOT NULL"
}
```

> ⚠️ **Good to Know:** when you provide a custom `adqlQuery`, keep the `b.oid` and `b.main_id` columns in your SELECT so the Actor can attach cross identifiers and build the SIMBAD link. Many fields are populated only for certain object types. Morphological type is set for galaxies, while spectral type and parallax are set for stars, so a field can be null for objects where it does not apply.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🌟 `mainId` | string | Primary SIMBAD identifier for the object |
| 🔭 `objectType` | string | SIMBAD object type code (otype) |
| 📝 `objectTypeText` | string | Object type text label |
| ↔ `ra` | number | Right ascension in degrees (ICRS, J2000) |
| ↕ `dec` | number | Declination in degrees (ICRS, J2000) |
| 🌈 `spectralType` | string | MK spectral type when known |
| 🌀 `morphType` | string | Morphological type when known |
| ✨ `magU`..`magK` | number | Magnitudes in U, B, V, R, G, J, H, K bands |
| 📐 `parallax` | number | Trigonometric parallax in mas |
| 📐 `parallaxError` | number | Parallax uncertainty in mas |
| 💨 `radialVelocity` | number | Radial velocity in km/s |
| 🔴 `redshift` | number | Redshift value |
| ➡ `properMotionRa` | number | Proper motion in RA in mas/yr |
| ⬆ `properMotionDec` | number | Proper motion in Dec in mas/yr |
| 📚 `referenceCount` | number | Number of bibliographic references |
| 🔗 `crossIds` | array | All catalog cross identifiers |
| 🔗 `simbadUrl` | string | Direct link to the SIMBAD object page |
| 🕒 `scrapedAt` | string | ISO timestamp of the run |
| ❌ `error` | string | Error message, null on success |

**Real sample records:**

```json
{
  "mainId": "BD+37  4133",
  "objectType": "**",
  "objectTypeText": "**",
  "ra": 314.92613800000004,
  "dec": 37.87467169999999,
  "spectralType": "A0",
  "magV": 9.826,
  "magR": 9.659,
  "magJ": 8.463,
  "magH": 8.073,
  "magK": 7.974,
  "referenceCount": 3,
  "crossIds": ["TIC 196017734", "WISE J205942.23+375228.8", "AG+37 2059", "BD+37  4133", "SAO  70769", "2MASS J20594224+3752287"],
  "simbadUrl": "https://simbad.u-strasbg.fr/simbad/sim-id?Ident=BD%2B37%20%204133",
  "scrapedAt": "2026-06-05T15:56:40.781Z",
  "error": null
}
```

```json
{
  "mainId": "HD 200207",
  "objectType": "*",
  "objectTypeText": "*",
  "ra": 315.22241304871994,
  "dec": 37.65310830967999,
  "spectralType": "G5",
  "magB": 9.09,
  "magV": 8.11,
  "magG": 7.84362,
  "magJ": 6.335,
  "parallax": 3.4084,
  "parallaxError": 0.0195,
  "radialVelocity": 5.22,
  "redshift": 0.000017412197361732495,
  "properMotionRa": 19.017,
  "properMotionDec": 3.95,
  "referenceCount": 11,
  "crossIds": ["TIC 269497348", "Gaia DR3 1871684217181831424", "HD 200207", "HIP 103706", "SAO  70788", "2MASS J21005337+3739112"],
  "simbadUrl": "https://simbad.u-strasbg.fr/simbad/sim-id?Ident=HD%20200207",
  "scrapedAt": "2026-06-05T15:56:40.959Z",
  "error": null
}
```

```json
{
  "mainId": "BD+37  4147",
  "objectType": "*",
  "objectTypeText": "*",
  "ra": 315.46926444354995,
  "dec": 37.6922044829,
  "spectralType": "F2",
  "magB": 10.3,
  "magV": 9.92,
  "magG": 9.830046,
  "magJ": 9.079,
  "parallax": 1.7737,
  "parallaxError": 0.0126,
  "properMotionRa": -0.883,
  "properMotionDec": -3.495,
  "referenceCount": 3,
  "crossIds": ["TIC 314385101", "Gaia DR3 1871705417141219712", "BD+37  4147", "TYC 3168-19-1", "2MASS J21015262+3741318"],
  "simbadUrl": "https://simbad.u-strasbg.fr/simbad/sim-id?Ident=BD%2B37%20%204147",
  "scrapedAt": "2026-06-05T15:56:41.117Z",
  "error": null
}
```

### ✨ Why choose this Actor

- Queries the official SIMBAD TAP service, the same data professional astronomers rely on.
- Full ADQL passthrough for advanced queries plus simple filters for everyone else.
- Cross identifiers attached automatically, so you can cross match against any catalog.
- Clean field names and consistent structure for every object type.
- No API keys to manage. The Actor handles the endpoint and a mirror host for resilience.

### 📈 How it compares to alternatives

| Approach | Cross IDs | ADQL control | Structured output | Maintenance |
|---|---|---|---|---|
| This Actor | Yes, every object | Full | Yes | None for you |
| Manual web form export | Limited | Partial | Tedious | Manual |
| Raw TAP scripting | You build it | Full | You build it | You maintain it |

### 🚀 How to use

1. Sign up for a free Apify account using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the SIMBAD Astronomical Objects Scraper.
3. Choose an object type or paste your own ADQL query, and set how many objects you want.
4. Click Start and watch records arrive in your dataset.
5. View the results in the table or pull them through the Apify API for your pipeline.

### 💼 Business use cases

**Research and survey planning**
| Need | How this helps |
|---|---|
| Target selection | Filter by type, brightness, or position |
| Catalog cross match | Map objects across HD, Gaia, 2MASS, and more |

**Data products and tooling**
| Need | How this helps |
|---|---|
| Sky atlas content | Populate maps with coordinates and types |
| Reference enrichment | Attach magnitudes and parallax to your objects |

**Education and outreach**
| Need | How this helps |
|---|---|
| Class datasets | Ready made tables of real astronomical objects |
| Planetarium shows | Curated object lists by type and visibility |

**Engineering and analytics**
| Need | How this helps |
|---|---|
| Pipeline ingestion | Stable structured records for your warehouse |
| Quality checks | Compare your catalog against SIMBAD values |

### 🔌 Automating SIMBAD Astronomical Objects Scraper

Connect the Actor to Make, Zapier, Slack, Airbyte, GitHub, and Google Drive through the Apify integrations. Trigger runs on a schedule, push fresh object lists to a spreadsheet, post new matches to a Slack channel, or sync results into your database with the Apify API and webhooks.

### 🌟 Beyond business use cases

- **Research:** assemble samples for population studies and statistics.
- **Personal:** plan a night of observing around bright objects in your sky.
- **Non-profit:** build open teaching resources for astronomy clubs.
- **Experimentation:** prototype cross matching and classification models.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to group objects by type, summarize the magnitude distribution, or suggest follow up queries.

### ❓ Frequently Asked Questions

**What is SIMBAD?** SIMBAD is the astronomical database maintained by CDS in Strasbourg, the reference for objects outside the Solar System.

**Do I need an API key?** No. The Actor uses the public TAP service and falls back to a mirror host automatically.

**Can I write my own query?** Yes. Provide an ADQL query in the input and it overrides the filters.

**Which coordinate system is used?** Right ascension and declination are in degrees, ICRS, epoch J2000.

**Why are some fields null?** Many measurements apply only to certain object types. Morphological type is set for galaxies, while spectral type and parallax are set for stars.

**What magnitudes are included?** U, B, V, R, G, J, H, and K when available for the object.

**What are cross identifiers?** Every alternative catalog name for an object, such as HD, HIP, Gaia, 2MASS, and TYC designations.

**How many objects can I get?** Free accounts return up to 10 objects per run. Paid accounts can return up to 1,000,000.

**Can I filter by object type without ADQL?** Yes. Use the object type selector and the identifier text filter.

**Is the data official?** Yes. It comes straight from the SIMBAD TAP service operated by CDS.

### 🔌 Integrate with any app

Use the Apify API, webhooks, and scheduler to plug the Actor into your stack. Run it on a cadence, react to finished runs, and deliver objects wherever your team works.

### 🔗 Recommended Actors

- [ParseForge collection](https://apify.com/parseforge) — browse more data Actors.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with SIMBAD or CDS Strasbourg. Only publicly available data collected.

# Actor input Schema

## `adqlQuery` (type: `string`):

Optional custom ADQL query against the SIMBAD TAP service. When provided, it overrides the object type and name filters below. Leave empty to use the filters or the default query.

## `objectType` (type: `string`):

Filter objects by SIMBAD object type code. For example G for galaxy, QSO for quasar, PM\* for high proper motion star. Leave as Any to return all types.

## `nameContains` (type: `string`):

Return only objects whose main identifier contains this text, for example HD, NGC, Gaia, or 2MASS. Leave empty to skip name filtering.

## `requireMagnitude` (type: `boolean`):

When enabled, only objects that have a measured V band magnitude are returned. Produces richer photometric records.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "objectType": "",
  "requireMagnitude": false,
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "adqlQuery": "",
    "nameContains": "",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/simbad-astronomical-objects-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 = {
    "adqlQuery": "",
    "nameContains": "",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/simbad-astronomical-objects-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 '{
  "adqlQuery": "",
  "nameContains": "",
  "maxItems": 10
}' |
apify call parseforge/simbad-astronomical-objects-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SIMBAD Astronomical Objects Scraper",
        "description": "Pull stars, galaxies, quasars, and nebulae from the SIMBAD database by object type, identifier, or custom ADQL query. Returns main identifier, RA and Dec, object type, spectral type, magnitudes, parallax, radial velocity, and cross identifiers. Good for observing plans and catalog work.",
        "version": "0.1",
        "x-build-id": "crpuzzznZ9HBMoJsT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~simbad-astronomical-objects-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-simbad-astronomical-objects-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/parseforge~simbad-astronomical-objects-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-simbad-astronomical-objects-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/parseforge~simbad-astronomical-objects-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-simbad-astronomical-objects-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": {
                    "adqlQuery": {
                        "title": "ADQL Query",
                        "type": "string",
                        "description": "Optional custom ADQL query against the SIMBAD TAP service. When provided, it overrides the object type and name filters below. Leave empty to use the filters or the default query."
                    },
                    "objectType": {
                        "title": "Object Type (otype)",
                        "enum": [
                            "",
                            "G",
                            "QSO",
                            "AGN",
                            "Star",
                            "PM*",
                            "SB*",
                            "**",
                            "EB*",
                            "WD*",
                            "ClG",
                            "Cl*",
                            "GlC",
                            "PN",
                            "SNR",
                            "HII",
                            "Neb",
                            "RG*",
                            "V*"
                        ],
                        "type": "string",
                        "description": "Filter objects by SIMBAD object type code. For example G for galaxy, QSO for quasar, PM* for high proper motion star. Leave as Any to return all types.",
                        "default": ""
                    },
                    "nameContains": {
                        "title": "Identifier Contains",
                        "type": "string",
                        "description": "Return only objects whose main identifier contains this text, for example HD, NGC, Gaia, or 2MASS. Leave empty to skip name filtering."
                    },
                    "requireMagnitude": {
                        "title": "Require V Magnitude",
                        "type": "boolean",
                        "description": "When enabled, only objects that have a measured V band magnitude are returned. Produces richer photometric records.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
