# Biomedical Equipment Manufacturers Email Scraper (`scraperoka/biomedical-equipment-manufacturers-email-scraper`) Actor

🔬 Biomedical Equipment Manufacturers Email Scraper extracts supplier contacts from biomedical equipment manufacturers—clean emails, company details & websites for faster outreach. ⚡ Ideal for B2B sales, lead gen, and market research. 📈 Reach qualified prospects faster.

- **URL**: https://apify.com/scraperoka/biomedical-equipment-manufacturers-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### Biomedical Equipment Manufacturers Email Scraper 🎯

Manually visiting dozens of biomedical equipment manufacturer sites to collect contact emails wastes hours you don’t have. **Biomedical Equipment Manufacturers Email Scraper** finds businesses for your target locations and extracts their contact details (including emails, phone numbers, and social media profiles) into a usable dataset. This Biomedical Equipment Manufacturers Email Scraper and its biomedical device manufacturer email finder variants are ideal for marketers, recruiters, and growth teams building outreach lists. In a single run, you can generate structured contact leads quickly—useful for everything from B2B medical equipment lead list scraping to research-backed follow-ups.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "name": "MedTech Systems Inc.",
  "website": "https://www.medtechsystems.com",
  "phone": "+1 (212) 555-0148",
  "full_address": "1200 Industry Blvd New York NY 10001 US",
  "city": "New York",
  "state": "NY",
  "zip": "10001",
  "country_code": "US",
  "scraped_emails": ["contact@medtechsystems.com", "sales@medtechsystems.com"],
  "scraped_phones": ["+1 (212) 555-0199"],
  "scraped_social_media": ["https://www.linkedin.com/company/medtech-systems/"],
  "emails_found": 2,
  "pages_scraped": 6,
  "avg_rating": 4.4,
  "total_reviews": 78,
  "lat": 40.758,
  "long": -73.9855,
  "place_id": "ChIJN1t_tDeuEmsRUsoyG83frY4",
  "scrape_status": "success",
  "email_found": "contact@medtechsystems.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `name` | string | The business name to identify the lead quickly |
| `website` | string | The company’s website where the actor looked for contact info |
| `phone` | string | The phone number associated with the business listing |
| `full_address` | string | A combined address string you can use for CRM notes or verification |
| `city` | string | The city used for location-based lead targeting |
| `state` | string | The state/region from the listing |
| `zip` | string | Postal code for segmentation and deduping |
| `country_code` | string | Country code to support international expansion |
| `scraped_emails` | array | All emails found on the business website(s) |
| `scraped_phones` | array | Additional phone numbers extracted from the website |
| `scraped_social_media` | array | Social links discovered on the website |
| `emails_found` | number | Count of emails found for that business |
| `pages_scraped` | number | How many pages were processed for the website scraping |
| `avg_rating` | number | Listing rating signal for lead prioritization |
| `total_reviews` | number | Total reviews associated with the business listing |
| `scrape_status` | string | Status such as `success`, `failed`, `no_website`, or `error` |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Biomedical Equipment Manufacturers Email Scraper?

There are a lot of ways to pull contact data for medical device manufacturers—here’s what sets **Biomedical Equipment Manufacturers Email Scraper** apart.

#### Location-focused lead discovery

You provide a business type (search term) and one or more locations. The actor then targets businesses for each location, which is useful for healthcare supplier email scraper workflows and B2B outreach planning.

#### Outputs are organized for contact workflows

Results include business identity and listing details, plus scraped contact fields like `scraped_emails`, `scraped_phones`, and `scraped_social_media`. This makes the output convenient for building a biomedical equipment supplier email database without manual cleanup.

#### Resilient scraping with validation options

The website scraping stage supports email validation (via `validate_emails`) and can extract phones and social links. It also handles failure states and records outcomes using fields like `scrape_status`.

#### Scales with batching and limits

You can cap the total number of businesses to process using `maxBusinesses`, and optionally control whether each location gets its own slice using `scrapeMaxBusinessesPerLocation`. This helps you manage how large your medical device email scraper output gets in each run.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "googleMapsSearchTerm": "Biomedical Equipment Manufacturers",
  "googleMapsLocation": ["New York"],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `googleMapsSearchTerm` | ✅ | The business type or niche for the email scraper (for example, `Biomedical Equipment Manufacturers`). |
| `googleMapsLocation` | ✅ | One or more geographic locations to search for businesses (for example, `New York`). |
| `maxBusinesses` | ⬜ | Target number of businesses to find (bounded to 1–1000). The scraper stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | ⬜ | If enabled, collects up to `maxBusinesses` results per location. If disabled, it combines all locations into one total limit. |
| `proxyConfiguration` | ⬜ | Proxy settings for scraping, recommended for larger runs. |
| ↳ `proxyConfiguration.proxy support` | ⬜ | When set, routes requests through Apify Proxy for improved scraping reliability. |

***

### Core Capabilities

#### Targeted lead discovery for biomedical equipment businesses

Using your `googleMapsSearchTerm` and `googleMapsLocation`, this Biomedical Equipment Manufacturers Email Scraper collects business listing details and then scrapes contact information from the associated website. It’s designed for lead sourcing like medical device manufacturers contact email list building and MDM biomedical equipment manufacturers email lookup.

#### Email, phone, and social extraction from websites

For businesses that have a `website`, the actor extracts `scraped_emails`, `scraped_phones`, and `scraped_social_media`. This gives you richer context than an email-only approach, helping you create a biomedical equipment company email leads dataset ready for outreach.

#### Status-aware output (so you can filter cleanly)

Each record includes `scrape_status`, along with counts like `emails_found` and `pages_scraped`. If a business has no website, the actor sets `scrape_status` to `no_website` and returns empty scrape arrays for `scraped_emails`, `scraped_phones`, and `scraped_social_media`.

#### Controlled scale with business limits

Use `maxBusinesses` to define your target size for each run, and `scrapeMaxBusinessesPerLocation` to decide whether your limit is global or per location. This is helpful for enterprise email extraction for medical manufacturers where you need consistent, predictable list sizing.

#### Built-in proxy support for reliable scraping

The actor accepts `proxyConfiguration` and supports `proxy support` to help avoid blocks and rate-limit issues during scraping. This makes it a practical option for healthcare supplier email scraper workloads that go beyond small test runs.

***

### Who Gets the Most Out of This

Here’s how different teams put **Biomedical Equipment Manufacturers Email Scraper** to work:

**B2B Outreach Marketers** — Use it to build a contact list of biomedical equipment manufacturers in specific cities, so campaigns can target the right suppliers with emails, phone numbers, and social links. You get a structured dataset you can upload directly into your outreach system.

**Sales Development Representatives** — Turn a set of target locations into a ready-to-contact lead list quickly, without manually checking sites. The output includes fields like `website`, `scraped_emails`, and `emails_found` so you can prioritize the most contact-rich companies.

**Healthcare Supplier Researchers** — Build a biomedical equipment supplier email database for analysis, segmentation, and reporting. The dataset retains listing context (like `avg_rating` and `total_reviews`) alongside scraped contacts to support data-driven decisions.

**Data Analysts & Enrichment Teams** — Combine business identity data with extracted contacts for downstream enrichment pipelines. The email and phone arrays (`scraped_emails`, `scraped_phones`) and counters (`pages_scraped`, `emails_found`) make it straightforward to track coverage and validate completeness.

**Automation & Integrations Specialists** — Pull results programmatically and feed them into CRMs or workflow tools. With consistent dataset fields like `place_id`, `full_address`, and `scrape_status`, it’s easier to deduplicate and manage incremental runs.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Biomedical Equipment Manufacturers Email Scraper from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find Biomedical Equipment Manufacturers Email Scraper.
2. **Enter your inputs** — set `googleMapsSearchTerm` and add one or more `googleMapsLocation` values (see the input fields above).
3. **Set your run limits** — choose `maxBusinesses` and decide whether `scrapeMaxBusinessesPerLocation` should be enabled for per-location caps.
4. **Configure proxy settings** — enable `proxyConfiguration` (including `proxy support`) if you’re running larger batches and want improved scraping reliability.
5. **Hit Run and watch the live log** — monitor progress as businesses are discovered and websites are processed for contact info.
6. **View results in the dataset tab** — each record includes contact fields like `scraped_emails`, `scraped_phones`, and `scraped_social_media`, plus `scrape_status`.
7. **Export your dataset** — download it as JSON, CSV, or Excel from the Apify dataset tab.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **Biomedical Equipment Manufacturers Email Scraper** plugs directly into your existing workflow.

You can export results from the Apify dataset tab in common formats including JSON, CSV, and Excel. This makes it easy to push outputs into spreadsheets, enrichment workflows, or reporting pipelines.

For automation and orchestration, you can connect the actor to your systems using Apify’s API access and webhooks, and you can also use automation tools like Zapier or Make to route results into CRMs and other downstream tools. For deeper setup and capabilities, refer to the Apify documentation: [apify.com/docs/api](https://apify.com/docs/api).

***

### Pricing & Free Trial

Biomedical Equipment Manufacturers Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can start with small test runs, validate email coverage using `emails_found`, and then scale based on your real lead targets.

Apify pricing is generally based on platform compute (CU) usage rather than a fixed monthly lock-in. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Scraping reliability | Uses `proxyConfiguration` (including `proxy support`) to improve stability for larger runs |
| Controlled output size | Stops when `maxBusinesses` is reached (with optional per-location limiting via `scrapeMaxBusinessesPerLocation`) |
| Missing or incomplete pages | If a business has no `website`, it’s recorded with `scrape_status: "no_website"` and empty scrape arrays |
| Failure visibility | Uses `scrape_status` and `scrape_error` (when available) so you can filter or retry intelligently |
| Faster workflows for batches | Scrapes multiple websites concurrently to reduce total time for medical device email scraper runs |

Limitations: This actor extracts contacts from publicly available web content tied to each business’s `website`. If companies don’t list contact emails on their websites, you may get fewer `scraped_emails` than expected. Private or login-gated content is not accessible.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial for Biomedical Equipment Manufacturers Email Scraper?

Yes. Apify offers a free tier for trying the actor with no credit card required. Coverage and results depend on what contact details are published on each business website.

#### Do I need to log in to use Biomedical Equipment Manufacturers Email Scraper?

No. You run the actor on Apify and it scrapes publicly available web content associated with each business `website`. Login-gated content is out of scope.

#### How accurate is the data?

It’s as accurate as the publicly available information on the businesses’ websites. The actor extracts emails into `scraped_emails` and counts them in `emails_found`, so you can measure how complete each website is.

#### How many results can I get per run?

You control the maximum with `maxBusinesses` (1–1000). If you enable `scrapeMaxBusinessesPerLocation`, the cap applies per location; otherwise it applies as a combined total across locations.

#### How often is the data updated or how fresh is it?

The dataset reflects data captured during your run. If you need fresher data for a medical device manufacturers contact email list, schedule repeated runs and track changes using fields like `place_id` and `scrape_status`.

#### Is this legal? Does it comply with GDPR / CCPA?

You should treat this as a tool for collecting publicly available data, and you are responsible for compliance with GDPR, CCPA, platform terms of service, and any applicable local regulations. Use responsibly and only for lawful purposes.

#### Can I export results to Google Sheets or Excel?

Yes. You can export the Apify dataset from the dataset tab as JSON, CSV, or Excel. From there, you can import into Google Sheets or any system that accepts those formats.

#### Can I run this on a schedule automatically?

Yes. You can schedule runs on the Apify platform so your Biomedical Equipment Manufacturers Email Scraper keeps producing updated email leads automatically.

#### Can I access this via API?

Yes. You can trigger runs and fetch results programmatically using Apify API access, then pipe outputs into your CRM or enrichment pipeline.

#### What happens if the actor hits an error?

The actor records outcomes per business using `scrape_status`. When failures happen for a particular website, you can review `scrape_error` (when present) and rerun only the affected segments.

***

### Need Help or Have a Request?

Got a question about Biomedical Equipment Manufacturers Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like improvements to output completeness for medical device email scraper workflows and webhook notifications when runs complete. We actively maintain this actor based on feedback.

***

### Disclaimer & Responsible Use

*Biomedical Equipment Manufacturers Email Scraper is the fastest, most reliable way to build biomedical equipment supplier email leads—start your free run today.*\
This actor collects **publicly available data** tied to each business `website`. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for compliance with GDPR, CCPA, platform ToS, and any applicable laws. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `googleMapsSearchTerm` (type: `string`):

Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').

## `googleMapsLocation` (type: `array`):

Target geographic location for the email scraper (e.g., 'Miami, Florida').

## `maxBusinesses` (type: `integer`):

Target number of businesses to find (1-1000). The scraper will stop when this target is reached.

## `scrapeMaxBusinessesPerLocation` (type: `boolean`):

If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.

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

Proxy settings for scraping. Recommended for large-scale scraping.

## Actor input object example

```json
{
  "googleMapsSearchTerm": "Biomedical Equipment Manufacturers",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "googleMapsSearchTerm": "Biomedical Equipment Manufacturers",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/biomedical-equipment-manufacturers-email-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 = {
    "googleMapsSearchTerm": "Biomedical Equipment Manufacturers",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/biomedical-equipment-manufacturers-email-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 '{
  "googleMapsSearchTerm": "Biomedical Equipment Manufacturers",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scraperoka/biomedical-equipment-manufacturers-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperoka/biomedical-equipment-manufacturers-email-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Biomedical Equipment Manufacturers Email Scraper",
        "description": "🔬 Biomedical Equipment Manufacturers Email Scraper extracts supplier contacts from biomedical equipment manufacturers—clean emails, company details & websites for faster outreach. ⚡ Ideal for B2B sales, lead gen, and market research. 📈 Reach qualified prospects faster.",
        "version": "1.0",
        "x-build-id": "7WM7DpQkaOlgxYKNV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~biomedical-equipment-manufacturers-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-biomedical-equipment-manufacturers-email-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/scraperoka~biomedical-equipment-manufacturers-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-biomedical-equipment-manufacturers-email-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/scraperoka~biomedical-equipment-manufacturers-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-biomedical-equipment-manufacturers-email-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": [
                    "googleMapsLocation",
                    "googleMapsSearchTerm"
                ],
                "properties": {
                    "googleMapsSearchTerm": {
                        "title": "Search Term",
                        "type": "string",
                        "description": "Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').",
                        "default": "Biomedical Equipment Manufacturers"
                    },
                    "googleMapsLocation": {
                        "title": "Location",
                        "type": "array",
                        "description": "Target geographic location for the email scraper (e.g., 'Miami, Florida').",
                        "default": [
                            "New York"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxBusinesses": {
                        "title": "Maximum Businesses With Emails",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Target number of businesses to find (1-1000). The scraper will stop when this target is reached.",
                        "default": 5
                    },
                    "scrapeMaxBusinessesPerLocation": {
                        "title": "Scrape Max Businesses Per Location",
                        "type": "boolean",
                        "description": "If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for scraping. Recommended for large-scale scraping."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
