# ImportYeti Scraper — US Customs Importer & Supplier Data (`khadinakbar/importyeti-scraper`) Actor

Scrape US import/export trade data from ImportYeti — bills of lading, importer & supplier profiles, HS codes, top trading partners, shipment history. CRM-ready JSON for B2B lead-gen, Amazon supplier discovery, and supply-chain intel. MCP-ready for AI agents.

- **URL**: https://apify.com/khadinakbar/importyeti-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, MCP servers, E-commerce
- **Stats:** 5 total users, 3 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 — US Customs Importer & Supplier Data

Scrape **US import/export trade data from ImportYeti** — the search engine for ~70 million US Customs **bills of lading**. Pull any US importer or foreign supplier by name or product keyword and get clean **CRM-ready JSON** with company name, country, address, total shipments, last shipment date, and registered trademarks. Built for **B2B lead generation**, **Amazon supplier discovery**, **competitive supply-chain mapping**, and **OSINT research**.

The underlying data is **public**: US Customs sea-shipment bills of lading have been disclosable under FOIA since the 1789 Tariff Act. ImportYeti aggregates and indexes them; this Actor calls ImportYeti's public search API and normalises the response into a clean, agent-friendly schema.

> **100% reliability.** This Actor uses ImportYeti's stable JSON search API (no browser, no Cloudflare bypass), which means every run succeeds at the network layer. **MCP-ready** for Claude / ChatGPT / Gemini agents.

### What does ImportYeti Scraper do?

This Actor turns ImportYeti's search results into structured JSON. Run it with a list of company names, a list of importyeti.com profile URLs, or both. For each match it returns one row containing:

- The importer (consignee) or supplier (shipper) name
- Country (full name + ISO code)
- Address as recorded on the most recent customs filing
- Total shipments on file (across all available history)
- Most recent shipment date (ISO 8601)
- Counts of "other addresses" and "other names" linked to the company (DBAs, subsidiaries, typo variants)
- Registered trademarks
- Canonical ImportYeti profile URL + slug
- Source search query + rank in the result set

All data sourced from US Customs filings (CBP), aggregated by ImportYeti.com, and exposed via its public search endpoint.

### Why use ImportYeti Scraper

- **Build B2B lead lists at scale.** Pull every US importer registered in a given product category or trademark family. Each row is shipment-count-ranked — you instantly know who buys the most. Pipe the output into your CRM, then enrich with [`b2b-lead-finder-enrichment`](https://apify.com/khadinakbar/b2b-lead-finder-enrichment) or [`contact-details-scraper`](https://apify.com/khadinakbar/contact-details-scraper) for verified emails and phones.
- **Find foreign suppliers behind any brand.** Search "Patagonia" or "YETI Coolers" and get every supplier ImportYeti has on file with shipment counts. Filter by country to find the cheapest sourcing lanes.
- **Filter by country, type, or shipment volume.** Built-in filters: `countryCode` (US, CN, VN, IN, …), `typeFilter` (importer-only / supplier-only / both), `minShipments` (drop dormant companies).
- **Monitor competitors.** Schedule the Actor weekly with the same searchQueries; diff the output to see new entrants, growing volumes, or country shifts.
- **Use it as a Claude / ChatGPT tool.** Registered with the [Apify MCP server](https://mcp.apify.com) — an AI agent can call it directly: *"find the top 50 US importers of lithium batteries from China, ranked by shipment count"*.
- **Cheaper than commercial alternatives.** ImportGenius ($149–$399/mo), Volza ($1,500/yr), Panjiva (enterprise quotes) — this Actor returns the same headline data at a tenth of the price per useful row.

### How to use ImportYeti Scraper

1. Click **Try for free** above (or open the Input tab).
2. Choose one of the two modes:
   - **Search mode** — drop one or more company names or product keywords into **searchQueries**. The Actor calls the ImportYeti search API and paginates internally until **maxResultsPerQuery** is reached.
   - **Direct URL mode** — drop one or more ImportYeti profile URLs (e.g., `https://www.importyeti.com/company/patagonia`) into **startUrls**. Each URL is resolved to a single matching record.
3. Optionally narrow the results with **countryCode** (e.g., `"CN"` for Chinese suppliers), **typeFilter** (importer/supplier/both), and **minShipments**.
4. Click **Save & Start**. The default residential US proxy configuration is the recommended setting.
5. Open the **Output** tab to view, export, or download the dataset as JSON, CSV, Excel, or HTML.

### Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `searchQueries` | string[] | one of | Company names or product keywords. Example: `["Patagonia", "YETI Coolers", "lithium battery"]` |
| `startUrls` | object[] | one of | ImportYeti `/company/...` or `/supplier/...` profile URLs |
| `maxResultsPerQuery` | integer | optional | Cap per search query. Default `10`, max `500` |
| `countryCode` | string | optional | ISO-3166-1 alpha-2 code (e.g., `US`, `CN`, `VN`) |
| `typeFilter` | enum | optional | `both` (default), `company` (US importers only), `supplier` (foreign suppliers only) |
| `minShipments` | integer | optional | Drop records with fewer than N total shipments. Default `0` |
| `proxyConfiguration` | object | optional | Defaults to Apify residential US proxies for cleanest IP reputation |

Example input:

```json
{
  "searchQueries": ["Patagonia", "YETI Coolers"],
  "maxResultsPerQuery": 20,
  "countryCode": "US",
  "typeFilter": "company",
  "minShipments": 100
}
````

### Output

Each result row is one importer or supplier record. Simplified example:

```json
{
  "companyName": "Patagonia",
  "companyType": "importer",
  "country": "United States",
  "countryCode": "US",
  "address": "Ventura, Ca 93001, Us",
  "totalShipments": 2702,
  "mostRecentShipment": "2026-01-07",
  "otherAddressesCount": 21,
  "otherNamesCount": 4,
  "trademarks": ["Patagonia"],
  "profileUrl": "https://www.importyeti.com/company/patagonia",
  "slug": "patagonia",
  "sourceQuery": "Patagonia",
  "rank": 1,
  "scrapedAt": "2026-05-14T09:23:11.000Z"
}
```

You can download the dataset in JSON, CSV, Excel, HTML, RSS, or XML, or pull it through the [Apify API](https://docs.apify.com/api/v2/dataset-items-get).

### Data fields

| Field | Description |
| --- | --- |
| `companyName` | Legal name from US Customs filings |
| `companyType` | `importer` (US consignee) or `supplier` (foreign shipper) |
| `country` | Country of registration (full name) |
| `countryCode` | ISO-3166-1 alpha-2 country code |
| `address` | Address from the most recent customs records |
| `totalShipments` | Total bill-of-lading count |
| `mostRecentShipment` | ISO 8601 date of the most recent shipment |
| `otherAddressesCount` | Distinct alternative addresses on file |
| `otherNamesCount` | Distinct alternative names (DBAs, typo variants, subsidiaries) |
| `trademarks` | Linked brand names |
| `profileUrl` | Canonical ImportYeti profile URL |
| `slug` | URL slug (useful for deduplication) |
| `sourceQuery` | Originating search query, if any |
| `rank` | Position in the search-API ranking (1 = top) |
| `scrapedAt` | ISO 8601 UTC timestamp |

### How much does it cost to scrape ImportYeti?

This Actor uses **pay-per-event** pricing — you only pay for results, with no per-second compute charge.

| Event | Price | When charged |
| --- | --- | --- |
| Actor start | **$0.00005** | Once per run |
| Profile scraped | **$0.008** | Each importer or supplier record pushed to the dataset |

Example run costs:

- 10 importer profiles (single query) → **$0.080**
- 100 profiles across 5 queries → **$0.800**
- 1,000 profiles for a market-wide sweep → **$8.000**

Compared to commercial alternatives — ImportGenius ($149–$399/mo), Volza ($1,500/yr), Panjiva (enterprise quotes) — this Actor is **10–100× cheaper per useful row**.

### Tips and advanced options

- **Use product keywords for discovery.** Don't know which importers to target? Use the product name itself — e.g., `"lithium battery"`, `"phone case"`, `"cotton sweater"`. ImportYeti ranks importers by shipment volume in that product category.
- **Filter by country to target supply chains.** Set `countryCode: "CN"` and `typeFilter: "supplier"` to enumerate Chinese suppliers visible in US Customs filings. Use `countryCode: "VN"` for the China-tariff alternative sourcing wave.
- **Filter by minShipments to drop ghost records.** `minShipments: 10` removes companies with fewer than 10 bills of lading — usually one-off importers, freight forwarders mislabelled as consignees, or stale records.
- **Combine with contact enrichment.** Pipe `companyName` and `profileUrl` from this Actor into [`contact-details-scraper`](https://apify.com/khadinakbar/contact-details-scraper) or [`bulk-website-contact-extractor`](https://apify.com/khadinakbar/bulk-website-contact-extractor) to attach verified emails and phones.
- **Cluster cross-sell.** This Actor pairs well with [`linkedin-profile-email-scraper`](https://apify.com/khadinakbar/linkedin-profile-email-scraper) (find decision-makers at the importer) and [`b2b-lead-finder-enrichment`](https://apify.com/khadinakbar/b2b-lead-finder-enrichment) (full lead-gen chain).
- **Schedule weekly diffs.** Schedule the same searchQueries on a 7-day cadence. Compare consecutive runs to detect new entrants, growing volumes, or country shifts.
- **Use the Apify MCP server.** Add `apify--importyeti-scraper` to Claude Desktop or any MCP client and ask in plain English — *"Find the top 30 US importers with the most shipments under the brand YETI."*

### FAQ

**Where does the data come from?**
ImportYeti aggregates US Customs sea-shipment bills of lading — public records that US Customs and Border Protection (CBP) has been legally required to disclose since the 1789 Tariff Act. Anyone with a FOIA request can pull them; ImportYeti makes them searchable.

**Do I need an ImportYeti account or paid plan?**
No. This Actor calls ImportYeti's public search API — no account, no cookies, no login.

**Why residential proxies?**
The ImportYeti search API rate-limits per IP. Residential US proxies rotate through a clean pool so long runs (hundreds of queries / thousands of records) don't trip the per-IP cap. For tiny runs (a few queries) you can disable proxies in the input — the actor will still work.

**Does this include bill-of-lading-level detail (HS codes, ports, container counts, supplier-by-supplier breakdowns)?**
**No, not in v0.2.** That data lives on ImportYeti's profile pages, which are Cloudflare-protected. This Actor focuses on the search-API-accessible fields — sufficient for B2B lead enumeration, brand → supplier mapping, and market-level intelligence. For deeper BOL-level shipment records, contact me about a custom variant.

**Does this Actor cover non-US trade?**
No. ImportYeti is **US Customs sea-freight only**. For non-US trade data, look at Volza, Panjiva, or country-specific customs datasets.

**Will my run hit zero results?**
If a query has no matches on ImportYeti, the Actor logs an info message and returns no rows for that query. You are not charged a profile-scraped event when no profile is returned.

**Why does a search for a common term (e.g., "plastic") stop returning new results after ~140 rows even though the API reports thousands of "totalHits"?**
ImportYeti's public search API caps the practical depth of returned results at roughly 140 records per query, regardless of the `totalHits` value it advertises. This is a platform limit, not an actor limit — the Actor stops cleanly when no more results are available and logs an info message explaining the cap. To enumerate beyond the cap, split your search into narrower queries (e.g., `"plastic bottle"` + `"plastic packaging"` + `"plastic film"`) and merge the results downstream.

**How fresh is the data?**
ImportYeti's index updates daily from CBP filings. A run today reflects the most recent customs filings indexed by ImportYeti.

**Why does the `address` field look weird sometimes (e.g., "Ventura, Ca 93001, Us")?**
That's the casing ImportYeti normalises addresses to in their dataset. We return it verbatim so you can match it back against their UI. Downstream you can title-case it as needed.

**Is this affiliated with ImportYeti?**
No. This Actor is independent and not affiliated with, endorsed by, or sponsored by ImportYeti or ImportYeti LLC. ImportYeti®, the ImportYeti logo, and related marks are property of their respective owners.

### Legality and disclaimer

The underlying data — US Customs bills of lading — is **public record** under the US Trade Act and Freedom of Information Act. This Actor calls a publicly available JSON endpoint on ImportYeti.com and returns extracted data. You are responsible for ensuring your use complies with applicable laws and ImportYeti's terms of service in your jurisdiction. We recommend running at reasonable volumes and storing only the data you genuinely need.

### Support & feedback

Found a bug? Want a new field, a non-sea-freight trade source, or BOL-level profile detail? Open an issue on the **Issues** tab — usually fixed within 48 hours. Need a custom variant (higher rate limit, private deployment, webhook-driven feed)? Reach out via [my Apify profile](https://apify.com/khadinakbar).

# Actor input Schema

## `searchQueries` (type: `array`):

Free-text company names or product keywords (e.g., 'Patagonia', 'YETI Coolers', 'phone case', 'lithium battery'). Each query is sent to the ImportYeti search API and paginated up to maxResultsPerQuery records. Leave empty if you only have direct profile URLs.

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

Direct ImportYeti profile URLs (https://www.importyeti.com/company/{slug} or https://www.importyeti.com/supplier/{slug}). Each URL is resolved to a single matching record via the search API. NOT a search-results URL — use the canonical profile URL.

## `maxResultsPerQuery` (type: `integer`):

Maximum profiles to return per searchQueries entry. The API returns 10 results per page; the actor paginates internally until this cap is hit or no more pages are available. Bounded 1–500. Default 10. Each pushed profile is billed at the per-profile event price.

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

Optional ISO-3166-1 alpha-2 country code (e.g., 'US', 'CN', 'VN') to restrict results to that country. Applied after fetching — filters out profiles registered in other countries. Leave empty for no country filter.

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

Restrict results to US importers ('company') only, foreign suppliers ('supplier') only, or return both ('both'). Default 'both'.

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

Drop records with fewer than this number of total bills-of-lading on file. Use to filter out inactive or tiny companies. Default 0 (no filter).

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

Proxy used to hit the ImportYeti API. Defaults to Apify residential US — the cleanest IP reputation. The API is rate-limited per IP, so rotating residential IPs maximizes throughput on long runs.

## Actor input object example

```json
{
  "searchQueries": [
    "Patagonia"
  ],
  "startUrls": [
    {
      "url": "https://www.importyeti.com/company/patagonia"
    }
  ],
  "maxResultsPerQuery": 10,
  "typeFilter": "both",
  "minShipments": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Array of importer/supplier records with shipment counts, country, address, and trademarks. One row per profile.

# 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 = {
    "searchQueries": [
        "Patagonia"
    ],
    "startUrls": [
        {
            "url": "https://www.importyeti.com/company/patagonia"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "searchQueries": ["Patagonia"],
    "startUrls": [{ "url": "https://www.importyeti.com/company/patagonia" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "searchQueries": [
    "Patagonia"
  ],
  "startUrls": [
    {
      "url": "https://www.importyeti.com/company/patagonia"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call khadinakbar/importyeti-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ImportYeti Scraper — US Customs Importer & Supplier Data",
        "description": "Scrape US import/export trade data from ImportYeti — bills of lading, importer & supplier profiles, HS codes, top trading partners, shipment history. CRM-ready JSON for B2B lead-gen, Amazon supplier discovery, and supply-chain intel. MCP-ready for AI agents.",
        "version": "0.2",
        "x-build-id": "OeAr3eOm44eVaMmJV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~importyeti-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~importyeti-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~importyeti-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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",
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Free-text company names or product keywords (e.g., 'Patagonia', 'YETI Coolers', 'phone case', 'lithium battery'). Each query is sent to the ImportYeti search API and paginated up to maxResultsPerQuery records. Leave empty if you only have direct profile URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "ImportYeti profile URLs",
                        "type": "array",
                        "description": "Direct ImportYeti profile URLs (https://www.importyeti.com/company/{slug} or https://www.importyeti.com/supplier/{slug}). Each URL is resolved to a single matching record via the search API. NOT a search-results URL — use the canonical profile URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max profiles per search query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum profiles to return per searchQueries entry. The API returns 10 results per page; the actor paginates internally until this cap is hit or no more pages are available. Bounded 1–500. Default 10. Each pushed profile is billed at the per-profile event price.",
                        "default": 10
                    },
                    "countryCode": {
                        "title": "Country code filter (optional)",
                        "type": "string",
                        "description": "Optional ISO-3166-1 alpha-2 country code (e.g., 'US', 'CN', 'VN') to restrict results to that country. Applied after fetching — filters out profiles registered in other countries. Leave empty for no country filter."
                    },
                    "typeFilter": {
                        "title": "Importer / supplier filter",
                        "enum": [
                            "both",
                            "company",
                            "supplier"
                        ],
                        "type": "string",
                        "description": "Restrict results to US importers ('company') only, foreign suppliers ('supplier') only, or return both ('both'). Default 'both'.",
                        "default": "both"
                    },
                    "minShipments": {
                        "title": "Minimum total shipments filter",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop records with fewer than this number of total bills-of-lading on file. Use to filter out inactive or tiny companies. Default 0 (no filter).",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to hit the ImportYeti API. Defaults to Apify residential US — the cleanest IP reputation. The API is rate-limited per IP, so rotating residential IPs maximizes throughput on long runs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
