# ImportYeti Scraper (`silentflow/importyeti-scraper`) Actor

Extract supplier and company profiles from ImportYeti US import records. Search by company name, product keyword, or location address. Get shipment counts, top trading partners, trademarks, addresses and country codes for each result. Pay per result only, proxies included, no compute costs.

- **URL**: https://apify.com/silentflow/importyeti-scraper.md
- **Developed by:** [SilentFlow](https://apify.com/silentflow) (community)
- **Categories:** Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 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

## ImportYeti Scraper

**Turn ImportYeti's US import database into structured supplier and company profiles.** Search by company, product, or address. Get shipment counts, trading partners, trademarks, and country data for every result. 100 results in 30 seconds.

### How it works

![How it works](https://api.apify.com/v2/key-value-stores/8ZVtCzmMF1ekOQv2M/records/how-it-works-v4.png)

### ✨ Why teams choose this over other ImportYeti scrapers

Spending hours copying supplier data from ImportYeti tabs? Hitting rate limits with basic Python scripts? Tired of scrapers that return half the fields?

- 🔍 **Search three ways, not one.** Company name, product keyword, or address in the same input. Find HDMI cable suppliers, all importers in Atlanta, or every entity named "Porsche" without switching tools.
- 📦 **10 clean fields per profile, always filled.** Name, type, address, country, shipment count, recent activity, top trading partners, trademarks, and a direct ImportYeti profile URL. No half-empty rows.
- ⚡ **100 results in 30 seconds.** Pagination handled automatically. Ask for 10 or 10,000, it scales linearly.
- 🎯 **Filter before you scrape.** Entity type (supplier vs company), minimum shipments, and recency filters. Stop paying for one-time importers you will never contact.
- 💰 **Pay per result, not per minute.** No compute costs, proxies included. You pay for rows delivered, period.
- 🔓 **No login, no API key, no cookies.** Works on publicly available data only.

### 🎯 What you can do with ImportYeti data

| Team | What they build |
|------|----------------|
| **Procurement** | Shortlist of 50 verified HDMI cable suppliers with 100+ shipments in the last 6 months |
| **Competitive Intel** | Full supplier map of a competitor's import activity, refreshed monthly |
| **Sales / BD** | Lead list of 500 US importers in a category, sorted by volume |
| **Supply Chain** | Map which suppliers serve multiple competitors in your segment |
| **Trade Compliance** | Screen suppliers by country of origin and shipment recency |
| **Market Research** | Compare import volumes across product categories and years |
| **Private Equity** | Diligence a target's supplier exposure and trading partner concentration |

### 📥 Input parameters

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `query` | String | (required) | Company name, supplier name, or product keyword |
| `searchType` | Select | `search` | `search` (by name) or `addresses` (by location) |
| `type` | Select | `any` | `any`, `supplier` (overseas exporters), or `company` (US importers) |

#### Filtering

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mostRecentShipment` | Select | `any` | `any`, `6mo` (past 6 months), or `12mo` (past 12 months) |
| `minShipments` | Integer | (none) | Only return entities with at least this many shipments |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxItems` | Integer | 100 | Maximum results to return (1 to 10,000) |

#### Advanced

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `requestTimeout` | Integer | 30 | HTTP request timeout in seconds |
| `debugMode` | Boolean | false | Enable detailed logs |

> **Note**: Proxies are automatically configured in Pay Per Event mode. No proxy setup needed.

### 📊 Output data

#### Company example

```json
{
  "name": "Porsche Cars North America",
  "type": "company",
  "detailUrl": "https://www.importyeti.com/company/porsche-cars-north-america",
  "address": "Atlanta, Ga 30354, Us",
  "countryCode": "US",
  "topSuppliers": [
    "Dr Ing H C F Porsche",
    "Porsche",
    "Porsche Lizenz"
  ],
  "trademarks": ["Porsche"],
  "totalShipments": 6686,
  "mostRecentShipment": "11/03/2026",
  "scrapedAt": "2026-04-10T09:15:22Z"
}
````

#### Supplier example

```json
{
  "name": "Dr Ing H C F Porsche",
  "type": "supplier",
  "detailUrl": "https://www.importyeti.com/supplier/dr-ing-h-c-f-porsche",
  "address": "Stuttgart Zuffenhausen Porscheplatz 1 D-70435 Stuttgart Germany",
  "countryCode": "DE",
  "topSuppliers": [
    "Porsche Cars North America",
    "Porsche Cars Australia P/L",
    "European Motor Distributors"
  ],
  "totalShipments": 6356,
  "mostRecentShipment": "11/03/2026",
  "scrapedAt": "2026-04-10T09:15:22Z"
}
```

### 🗂️ Data fields

| Category | Fields |
|----------|--------|
| **Identity** | name, type, detailUrl |
| **Location** | address, countryCode |
| **Volume** | totalShipments |
| **Recency** | mostRecentShipment |
| **Relationships** | topSuppliers (top 4 trading partners) |
| **Brand** | trademarks (when available) |
| **Meta** | scrapedAt |

For supplier rows, `topSuppliers` contains the supplier's top customers (US importers). The field name stays the same for schema consistency.

### 🚀 Examples

#### Find HDMI cable suppliers

```json
{
  "query": "hdmi cable",
  "type": "supplier",
  "maxItems": 50
}
```

#### Pull every importer in Atlanta

```json
{
  "query": "atlanta",
  "searchType": "addresses",
  "maxItems": 100
}
```

#### Get active high-volume electronics companies

```json
{
  "query": "electronics",
  "type": "company",
  "mostRecentShipment": "6mo",
  "minShipments": 500,
  "maxItems": 200
}
```

#### Map a competitor's supplier network

```json
{
  "query": "walmart",
  "type": "company",
  "maxItems": 100
}
```

#### Quick supplier shortlist for sourcing

```json
{
  "query": "lithium battery",
  "type": "supplier",
  "mostRecentShipment": "12mo",
  "minShipments": 50,
  "maxItems": 30
}
```

#### Investigate a specific brand's importers

```json
{
  "query": "porsche",
  "type": "company",
  "maxItems": 50
}
```

### 🤖 Copy to your AI assistant

Paste this block into Claude, ChatGPT, or Cursor to give it full context about this scraper:

```
You have access to the ImportYeti Scraper on Apify: silentflow/importyeti-scraper

It extracts US import records from importyeti.com. Input schema:
- query (required, string): company name, product keyword, or address
- searchType ("search" by default, or "addresses" for location search)
- type ("any" by default, or "supplier" / "company")
- mostRecentShipment ("any" by default, "6mo", or "12mo")
- minShipments (integer, omit for no floor)
- maxItems (integer, default 100, max 10000)

Output per result (10 fields):
- name (string): entity name
- type ("company" or "supplier")
- detailUrl (string): full ImportYeti profile URL
- address (string): primary address
- countryCode (string): ISO 3166-1 alpha-2
- totalShipments (integer): total sea shipments on record
- mostRecentShipment (string): "DD/MM/YYYY"
- topSuppliers (array of string): top 4 trading partners
- trademarks (array of string, optional)
- scrapedAt (string): ISO 8601 UTC

Pay per result. Proxies included. Use apify-client for Python or JS.
```

### 💻 Integrations

#### Feed results into a supplier database (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("silentflow/importyeti-scraper").call(run_input={
    "query": "hdmi cable",
    "type": "supplier",
    "mostRecentShipment": "6mo",
    "minShipments": 50,
    "maxItems": 100,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['name']} ({item['countryCode']}) - {item['totalShipments']} shipments")
    print(f"  Top partners: {', '.join(item.get('topSuppliers', [])[:3])}")
    print(f"  Profile: {item['detailUrl']}")
```

#### Build a competitor monitoring pipeline (JavaScript)

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('silentflow/importyeti-scraper').call({
    query: 'walmart',
    type: 'company',
    maxItems: 200,
});

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

const sorted = items.sort((a, b) => b.totalShipments - a.totalShipments);
sorted.slice(0, 10).forEach(item => {
    console.log(`${item.name}: ${item.totalShipments} shipments, recent: ${item.mostRecentShipment}`);
});
```

#### Export to CSV for spreadsheet analysis (Python)

```python
import csv
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("silentflow/importyeti-scraper").call(run_input={
    "query": "electronics",
    "type": "company",
    "maxItems": 500,
})

with open("importers.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["name", "country", "shipments", "recent", "top_supplier", "url"])
    for item in client.dataset(run["defaultDatasetId"]).iterate_items():
        top = (item.get("topSuppliers") or [""])[0]
        writer.writerow([
            item["name"],
            item["countryCode"],
            item["totalShipments"],
            item["mostRecentShipment"],
            top,
            item["detailUrl"],
        ])
```

#### Schedule weekly runs with Apify CLI

```bash
apify call silentflow/importyeti-scraper \
  --input='{"query": "solar panel", "type": "supplier", "maxItems": 100}' \
  > weekly-suppliers.json
```

### 📈 Performance

| Metric | Value |
|--------|-------|
| **Speed** | ~100 results in 30 seconds (including pagination) |
| **Results per page** | 10 (ImportYeti fixed page size) |
| **Max items per run** | 10,000 |
| **Success rate** | 100% on our test runs |
| **Data freshness** | ImportYeti updates the source database daily |
| **Pagination** | Automatic, no configuration |
| **Concurrent runs** | Supported, each run uses an isolated session |

### 💾 Data export

Results are available in:

- **JSON** (full API output, best for pipelines)
- **CSV** (flat spreadsheet with all 10 fields, array fields comma-joined)
- **Excel** (.xlsx, native formatting)
- **RSS** and **JSONL** (for streaming consumers)

Download from the Apify console or fetch programmatically with the dataset API:

```
https://api.apify.com/v2/datasets/{DATASET_ID}/items?format=csv&token=YOUR_TOKEN
```

### 💡 Tips for best results

1. **Product keywords beat category names.** "hdmi cable" returns more suppliers than "cables". ImportYeti matches against raw product descriptions in bills of lading, which are specific.
2. **Filter with `type` before scaling.** `type: "supplier"` gives you overseas manufacturers, `type: "company"` gives you US importers. Without the filter, you get both mixed and waste half your quota.
3. **Combine `minShipments` with `mostRecentShipment`.** `minShipments: 50` + `mostRecentShipment: "6mo"` gives you active, high-volume traders only. Perfect for sourcing shortlists.
4. **Address search is for locations, not names.** Use `searchType: "addresses"` with a city or state to map all importers operating from that area.
5. **Start small, then scale.** Run with `maxItems: 25` first to validate the query returns what you expect, then rerun with `maxItems: 1000` to pull the full list.

### ❓ FAQ

**What data does ImportYeti contain?**
US import records extracted from sea shipment bills of lading. Covers company names, addresses, supplier relationships, trademarks, and shipment volumes back to 2015.

**What is the difference between "company" and "supplier"?**
A "company" is a US importer (the consignee on the bill of lading). A "supplier" is the overseas manufacturer or exporter (the shipper). The same entity can appear as both depending on trade direction.

**How current is the data?**
ImportYeti updates its database daily. The `mostRecentShipment` field shows the latest available record for each entity. Most active importers have shipments from the past week.

**Can I search by HS code?**
Not directly. Use product keywords instead. ImportYeti matches against product descriptions in bills of lading, which contain HS code classifications and product language.

**What does "topSuppliers" contain for supplier rows?**
For supplier rows, the field lists top customers (US importers), not the supplier's own suppliers. The field name is kept identical across rows for schema consistency.

**Do I need an ImportYeti account?**
No. The scraper extracts publicly available data. No login, no API key, no cookies.

**Can I scrape multiple queries in one run?**
One query per run. Schedule multiple runs if you need to compare several queries, or chain runs with an Apify task or CLI script.

**What happens if my search returns fewer results than maxItems?**
The scraper stops at the actual result count. You only pay for rows delivered, never for empty slots.

**Why do some results have "Missing in source document" in topSuppliers?**
That string comes from ImportYeti itself, which masks confidential shipper names when the underlying bill of lading marks the shipper as private. It is not a scraping error.

**Why does a foreign company show countryCode "US"?**
ImportYeti tags companies by the destination market of their imports, not by physical HQ. A company like "Porsche Chile" appearing as a US consignee will show `countryCode: "US"`. This reflects ImportYeti's own classification.

### ⚖️ Legal

This Actor extracts publicly available data from ImportYeti. It does not bypass any login, paywall, or CAPTCHA. Users are responsible for complying with ImportYeti's terms of service and applicable laws in their jurisdiction. The data returned is informational; verify accuracy for regulated use cases.

### 📬 Support

Need something this scraper doesn't do yet? We ship features fast.

- Feature requests go straight to our backlog
- Enterprise needs? We do custom integrations and high-volume plans
- Pricing questions? Check the Monetization tab on the actor page

Response time: usually under 24 hours.

Check out our other scrapers: [silentflow on Apify](https://apify.com/silentflow)

# Actor input Schema

## `query` (type: `string`):

Company name, supplier name, or product keyword.<br><br>Examples:<br>- <code>porsche</code>: find Porsche and related entities<br>- <code>hdmi cable</code>: find importers/suppliers of HDMI cables<br>- <code>atlanta</code>: use with <b>By Address</b> search type

## `searchType` (type: `string`):

How to search ImportYeti.<br><br><b>By Name</b>: search company/supplier names and product keywords.<br><b>By Address</b>: search by location (city, state, address).

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

Filter by entity type.<br><br><b>Any</b>: both suppliers and companies.<br><b>Supplier</b>: overseas manufacturers/exporters.<br><b>Company</b>: US importers/consignees.

## `mostRecentShipment` (type: `string`):

Only include entities with at least one shipment within this period.

## `minShipments` (type: `integer`):

Only return entities with at least this many total shipments. Filters out low-volume or one-time importers.

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

Maximum number of results to return.

## `requestTimeout` (type: `integer`):

HTTP request timeout in seconds.

## `debugMode` (type: `boolean`):

Activate to see detailed logs.

## Actor input object example

```json
{
  "query": "porsche",
  "searchType": "search",
  "type": "any",
  "mostRecentShipment": "any",
  "maxItems": 25,
  "requestTimeout": 30,
  "debugMode": false
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped profiles with full data.

## `resultsCSV` (type: `string`):

CSV format for spreadsheet analysis.

## `resultsExcel` (type: `string`):

Excel format export.

# 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 = {
    "query": "porsche",
    "maxItems": 25,
    "requestTimeout": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("silentflow/importyeti-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 = {
    "query": "porsche",
    "maxItems": 25,
    "requestTimeout": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("silentflow/importyeti-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 '{
  "query": "porsche",
  "maxItems": 25,
  "requestTimeout": 30
}' |
apify call silentflow/importyeti-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ImportYeti Scraper",
        "description": "Extract supplier and company profiles from ImportYeti US import records. Search by company name, product keyword, or location address. Get shipment counts, top trading partners, trademarks, addresses and country codes for each result. Pay per result only, proxies included, no compute costs.",
        "version": "1.0",
        "x-build-id": "hZKyNBPq7qrhdZ8N9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/silentflow~importyeti-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-silentflow-importyeti-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/silentflow~importyeti-scraper/runs": {
            "post": {
                "operationId": "runs-sync-silentflow-importyeti-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/silentflow~importyeti-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-silentflow-importyeti-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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Company name, supplier name, or product keyword.<br><br>Examples:<br>- <code>porsche</code>: find Porsche and related entities<br>- <code>hdmi cable</code>: find importers/suppliers of HDMI cables<br>- <code>atlanta</code>: use with <b>By Address</b> search type"
                    },
                    "searchType": {
                        "title": "Search Type",
                        "enum": [
                            "search",
                            "addresses"
                        ],
                        "type": "string",
                        "description": "How to search ImportYeti.<br><br><b>By Name</b>: search company/supplier names and product keywords.<br><b>By Address</b>: search by location (city, state, address).",
                        "default": "search"
                    },
                    "type": {
                        "title": "Entity Type",
                        "enum": [
                            "any",
                            "supplier",
                            "company"
                        ],
                        "type": "string",
                        "description": "Filter by entity type.<br><br><b>Any</b>: both suppliers and companies.<br><b>Supplier</b>: overseas manufacturers/exporters.<br><b>Company</b>: US importers/consignees.",
                        "default": "any"
                    },
                    "mostRecentShipment": {
                        "title": "Most Recent Shipment",
                        "enum": [
                            "any",
                            "6mo",
                            "12mo"
                        ],
                        "type": "string",
                        "description": "Only include entities with at least one shipment within this period.",
                        "default": "any"
                    },
                    "minShipments": {
                        "title": "Minimum Shipments",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return entities with at least this many total shipments. Filters out low-volume or one-time importers."
                    },
                    "maxItems": {
                        "title": "Maximum number of items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of results to return.",
                        "default": 100
                    },
                    "requestTimeout": {
                        "title": "Request timeout (seconds)",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "HTTP request timeout in seconds.",
                        "default": 30
                    },
                    "debugMode": {
                        "title": "Debug Mode",
                        "type": "boolean",
                        "description": "Activate to see detailed logs.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```