# ImportYeti: Bills of Lading, Suppliers, HS Codes & Trade Lanes (`memo23/importyeti-scraper`) Actor

Map any company's US import supply chain: 50 recent bills of lading per target plus supplier league tables, HS-code breakdowns and port-to-port trade lanes. Covers company, supplier, HS-code and country targets in one actor. Resumable runs — never pay twice for the same record.

- **URL**: https://apify.com/memo23/importyeti-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Lead generation, Agents, AI
- **Stats:** 20 total users, 19 monthly users, 98.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 record scrapeds

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 — Bills of Lading, Suppliers, HS Codes & Trade Lanes

Turn any ImportYeti company, supplier, HS-code, or country page into structured US import data: bill-of-lading rows with full counterparty addresses, supplier/customer league tables, HS-code breakdowns, and port-to-port trade lanes — in one actor, one run, one dataset.

#### How it works

![How ImportYeti Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-importyeti.png)

#### ✨ Why use this scraper?

- **Four target types in one actor** — US importers, foreign suppliers, HS codes (`84`, `8471`, `847130`), and country/location directories. Competing actors split these across separate paid products.
- **Richer rows than the visible page** — the actor reads the page's full embedded data payload, not the HTML table. You get ISO dates, complete counterparty street addresses, shipping routes, and estimated freight cost per shipment — fields the on-page table doesn't even render.
- **Four record types, one dataset** — `bill_of_lading`, `summary`, `top_partner`, and `trade_lane` records, each tagged for easy filtering. Turn on only what you need.
- **Resume without re-paying** — when `maxItems` truncates a run, a `resumeCursor` is written to the run OUTPUT. Paste it into the next run and the crawl continues exactly where it stopped.
- **Built for Cloudflare** — ImportYeti blocks datacenter IPs; this actor ships with residential US proxying and browser-grade TLS fingerprints by default. No CAPTCHAs to babysit.
- **Honest scope** — 50 most-recent shipments per target (that's what ImportYeti exposes publicly). No paywall bypass, no login, no fabricated fields.

#### 🎯 Use cases

| Who | What they do with it |
|---|---|
| Sourcing & procurement teams | Find every foreign factory shipping a product category to the US, with full addresses and shipment volumes |
| Competitive intelligence analysts | Map a competitor's supplier network, shipment cadence, and freight lanes |
| Sales & lead-gen teams | Build lists of active US importers per HS code or country, enriched with websites and shipment history |
| Trade & tariff researchers | Roll up shipments by HS chapter, origin country, and entry port to quantify tariff exposure |
| Logistics & freight forwarders | See which carriers (SCAC) and port pairs dominate a shipper's traffic, with TEU and estimated spend |
| Supply-chain risk teams | Check UFLPA flags, supplier concentration, and year-over-year volume shifts per partner |

#### 📥 Supported inputs

| Input | Format | Example |
|---|---|---|
| `companies` | slug, path, or URL | `apple`, `/company/walmart`, `https://www.importyeti.com/company/costco` |
| `suppliers` | slug, path, or URL | `foxconn-interconnect-technology` |
| `hsCodes` | 2/4/6-digit code or URL | `84`, `8471`, `847130`, `https://www.importyeti.com/hs-codes/8471-automatic-data-processing-machines-and` |
| `locations` | country slug or location URL | `china`, `https://www.importyeti.com/location/company/united-states-of-america/state/4662168-tennessee` |
| `startUrls` | any importyeti.com URL | company, supplier, HS-code, location, or `/tags/...` product-tag pages — auto-classified |

**Not supported:** free-text search (disallowed by the site's robots.txt — paste the URLs you care about instead), per-BOL detail pages behind ImportYeti's premium tier, and contact emails/phones the site masks for free users.

#### ⚠️ Proxy requirement

ImportYeti's Cloudflare edge blocks datacenter IPs on sight. The input schema defaults to **residential US** proxies and that is the configuration this actor is tested against. Leave the default alone unless you know exactly what you're doing.

#### 🔄 How it works

1. Every entry in `companies`, `suppliers`, `hsCodes`, `locations`, and `startUrls` is normalized into a target URL. Bare HS codes resolve through the site's own redirect, so `8471` works as well as the full slugged URL.
2. Each target page is fetched once through residential US proxies with browser-grade TLS fingerprints, retrying across rotating IPs on failure.
3. The page's embedded JSON payload is extracted — this carries the full 50-row shipment table plus every rollup the page knows about, including fields the visible HTML never renders.
4. Records are mapped in a stable order per target — summary → bill-of-lading rows → top partners → trade lanes — and streamed to the dataset as each target completes.
5. If `maxItems` cuts the run short, the remaining work is encoded into a `resumeCursor` in the run OUTPUT. Start a new run with that cursor to continue without duplicate records or duplicate charges.

#### ⚙️ Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `companies` | array | `[]` | US importer (consignee) slugs or URLs |
| `suppliers` | array | `[]` | Foreign supplier (shipper) slugs or URLs |
| `hsCodes` | array | `[]` | HS codes — 2-digit chapter, 4-digit heading, or 6-digit subheading |
| `locations` | array | `[]` | Country slugs or full `/location/...` URLs |
| `locationType` | string | `supplier` | Whether bare country slugs target the supplier or company directory |
| `startUrls` | array | `[]` | Any importyeti.com URLs, auto-classified |
| `includeBols` | boolean | `true` | Emit per-shipment `bill_of_lading` rows (up to 50 per target) |
| `includeSummary` | boolean | `true` | Emit one `summary` record per target |
| `includeTopPartners` | boolean | `false` | Emit `top_partner` records from the Top Suppliers / Top Companies tables |
| `includeTradeLanes` | boolean | `false` | Emit `trade_lane` port-pair records |
| `resumeCursor` | string | — | Cursor from a previous run's OUTPUT to continue where it stopped |
| `maxItems` | integer | `1000` | Hard cap on total records across all targets and record types |
| `maxConcurrency` | integer | `10` | Target pages fetched in parallel |
| `proxy` | object | residential US | Apify proxy configuration — residential US required |

#### 📊 Output overview

All record types ride in the same dataset and share a common header — `record_type`, `target_type`, `target_slug`, `target_url`, `target_name`, `source_url`, `scraped_at` — so one `record_type` filter cleanly splits the output into four flat tables. A typical company target with everything enabled yields 1 summary + 50 BOL rows + up to 50 top partners + its trade lanes.

#### 📦 Output samples

**`bill_of_lading`** — one per shipment row:

```json
{
    "record_type": "bill_of_lading",
    "target_type": "company",
    "target_slug": "apple",
    "target_url": "https://www.importyeti.com/company/apple",
    "target_name": "Apple",
    "arrival_date": "2026-01-21",
    "bill_of_lading": "SHPT012025121832",
    "bill_type": "H",
    "house_bol": "SHPT012025121832",
    "master_bol": "ZIMUBCN10198564",
    "carrier_scac": "ZIMU",
    "counterparty_name": "Galan Textile Machinery Sl",
    "counterparty_address": "Calle Francisco Oller 91 Barcelona Es",
    "counterparty_city": "Barcelona",
    "counterparty_country": "Spain",
    "counterparty_country_code": "ES",
    "counterparty_slug": "galan-textile-machinery",
    "counterparty_url": "https://www.importyeti.com/supplier/galan-textile-machinery",
    "weight_kg": 690,
    "quantity": 2,
    "quantity_unit": "pkg",
    "container_count": 1,
    "product_description": "Double Twisting Machine Bobbins First Twist Overhead Creel Winding Machine",
    "shipping_route": "Eu,Transatlantic",
    "est_freight_cost_usd": 23.49,
    "source_url": "https://www.importyeti.com/company/apple",
    "scraped_at": "2026-07-10T22:45:21.048Z"
}
````

**`summary`** — one per target (trimmed):

```json
{
    "record_type": "summary",
    "target_type": "company",
    "target_slug": "apple",
    "target_name": "Apple",
    "total_shipments": 2443,
    "first_shipment_date": "2015-03-25",
    "most_recent_shipment_date": "2026-01-21",
    "website": "apple.com",
    "also_known_as": ["Apple Aps", "Apple Inc"],
    "hs_codes": [
        { "code": "85", "description": "Electric motors/Appliances", "shipments": 1186, "weight_kg": 5464266, "teu": 2010 }
    ],
    "top_carriers": [
        { "scac": "FTNV", "name": "Fedex Trade Networks Transport & Brokerage", "shipments": 1666 }
    ],
    "bill_type_breakdown": { "house": 2439, "regular": 3, "in_bond_regular": 1 },
    "uflpa_flag": false,
    "trademarks_count": 1620
}
```

**`top_partner`** — one per row of the Top Suppliers / Top Companies tables (trimmed):

```json
{
    "record_type": "top_partner",
    "partner_type": "supplier",
    "partner_name": "Hon Hai Precision Industrial",
    "partner_address": "10Th Indl Dist N 2 Donghuan Rd Long Hua Baoan Shenzhen Gd Cn",
    "partner_country": "China",
    "origin_country": "Hong Kong S.A.R.",
    "total_weight_kg": 3373940,
    "total_teu": 1491,
    "hs_codes": ["8504.40", "8517.62", "8471.30"],
    "top_counterparties": [
        { "name": "Amazon Services", "shipments_12m": 770, "total_shipments": 1548 }
    ]
}
```

**`trade_lane`** — one per port pair:

```json
{
    "record_type": "trade_lane",
    "exit_port": "Hong Kong",
    "exit_port_country": "Hong Kong S.A.R.",
    "entry_port": "Los Angeles, Ca",
    "entry_port_region": "California",
    "shipments": 607,
    "weight_kg": 2092579,
    "teu": 1021,
    "est_shipping_cost_usd": 519044
}
```

#### 🗂 Key output fields

| Group | Fields | Notes |
|---|---|---|
| Target context | `record_type`, `target_type`, `target_slug`, `target_url`, `target_name` | On every record — filter and join on these |
| BOL identity | `bill_of_lading`, `bill_type`, `house_bol`, `master_bol`, `carrier_scac` | SCAC derived from the master BOL prefix |
| Counterparty | `counterparty_name`, `counterparty_address`, `counterparty_city`, `counterparty_country`, `counterparty_url` | Supplier when the target is an importer; customer when the target is a supplier |
| Shipment | `arrival_date`, `weight_kg`, `quantity`, `quantity_unit`, `container_count`, `product_description`, `shipping_route`, `est_freight_cost_usd` | Freight cost is ImportYeti's estimate; `null` when the site has none |
| Summary rollups | `total_shipments`, `first/most_recent_shipment_date`, `hs_codes[]`, `hts_codes[]`, `top_carriers[]`, `bill_type_breakdown`, `website`, `uflpa_flag` | Company/supplier summaries are the richest |
| Partner tables | `partner_name`, `partner_address`, `origin_country`, `total_shipments`, `total_weight_kg`, `total_teu`, `hs_codes[]`, `top_counterparties[]` | Supplier discovery without fetching every profile |
| Trade lanes | `exit_port`, `entry_port`, `entry_port_region`, `shipments`, `weight_kg`, `teu`, `est_shipping_cost_usd` | Port-pair rollups per target |

#### ❓ FAQ

**How do I scrape ImportYeti?**
Paste company slugs (`apple`), supplier slugs, HS codes (`8471`), country slugs (`china`), or any importyeti.com URL. Every input is normalized and classified automatically — slugs, paths, and full URLs all work interchangeably.

**Can I get more than 50 shipments per company?**
No — 50 recent shipments per target is what ImportYeti exposes publicly, and this actor doesn't bypass their paid tier. What you *can* do is widen coverage: target the company **and** its top suppliers **and** the relevant HS codes in one run, which triangulates far more of the picture than any single page.

**What's the difference between `top_partner` and fetching each supplier page?**
`top_partner` records come from the target page's own league table — up to 50 partners with addresses, volumes, HS codes, and their top counterparties, for the price of the one page you already fetched. Fetch individual supplier pages only for the partners you actually care about.

**How does the resume cursor work?**
When `maxItems` stops a run early, the OUTPUT tab contains a `resumeCursor` string encoding exactly which targets (and how many records per target) are still owed. Start a new run with that cursor in the `resumeCursor` field — delivery continues from that point, so you never pay twice for the same record.

**Does this scraper need proxies?**
Yes — residential US. ImportYeti's Cloudflare edge blocks datacenter IPs. The default configuration already has this right; don't switch it off.

**Are emails and phone numbers included?**
Company websites are included when ImportYeti publishes them, and supplier phone numbers when the site exposes them publicly. Emails and masked phone numbers behind ImportYeti's premium tier are **not** included — the site redacts them server-side and this actor doesn't pretend otherwise.

#### 💬 Support

Found an issue or need a field this actor doesn't emit yet? Open an issue on the actor's **Issues** tab in Apify Console — issues are typically answered within a day.

#### 🛠 Additional services

Need a custom extraction pipeline, another trade-data source (Panjiva-style datasets, port statistics, customs registries), or this data delivered to your warehouse on a schedule? Get in touch via the Issues tab.

#### 🔎 Explore more scrapers

More scrapers by the same author are available on the [memo23 Apify profile](https://apify.com/memo23) — 270+ actors covering business directories, real-estate portals, job boards, and lead-generation sources.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by ImportYeti, LLC or any of its subsidiaries or affiliates. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available import-record pages — no authenticated endpoints, premium-tier features, or content behind an ImportYeti login. US bill-of-lading data is public information published by CBP. Users are responsible for ensuring their use complies with ImportYeti's Terms of Service, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organisation.

***

### SEO Keywords

importyeti scraper, scrape importyeti, importyeti api, apify importyeti, bill of lading scraper, bill of lading data, us import records, us customs data, import export data, supplier discovery tool, find suppliers by hs code, hs code data, shipment data scraper, trade data api, sea shipment records, panjiva alternative, importgenius alternative, supply chain intelligence, competitor supplier lookup, freight lane data, consignee data, shipper data, sourcing intelligence

# Actor input Schema

## `companies` (type: `array`):

ImportYeti company slugs or URLs for US importers. Examples: `apple`, `walmart`, `/company/costco`, or `https://www.importyeti.com/company/apple`.

## `suppliers` (type: `array`):

ImportYeti supplier slugs or URLs for foreign shippers. Examples: `foxconn-interconnect-technology` or `https://www.importyeti.com/supplier/foxconn-interconnect-technology`.

## `hsCodes` (type: `array`):

HS codes: 2-digit chapter (`84`), 4-digit heading (`8471`), or 6-digit subheading (`847130`). Full `/hs-codes/...` URLs also work. Each code yields the most recent shipments plus top importers and suppliers for that code.

## `locations` (type: `array`):

Country slugs (`china`, `vietnam`, `india`) or full ImportYeti location URLs (e.g. `https://www.importyeti.com/location/supplier/china/country`, state/county/city URLs work too). Bare slugs use the directory type selected below.

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

Whether bare `locations` slugs point at the foreign-supplier directory or the US-importer directory. Ignored for full location URLs, which already contain the type.

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

Catch-all list: any importyeti.com company, supplier, HS-code, location, or product-tag (`/tags/...`) URL. Mixed types are fine — each URL is classified automatically.

## `includeBols` (type: `boolean`):

Per-shipment rows: arrival date, house/master BOL numbers, carrier SCAC, counterparty name + full address, weight, quantity, containers, product description, shipping route, and estimated freight cost.

## `includeSummary` (type: `boolean`):

Target-level rollup: total shipments, first/most-recent shipment dates, HS-code breakdown, top carriers, website, aliases, bill-type split, and UFLPA flag.

## `includeTopPartners` (type: `boolean`):

The Top Suppliers / Top Companies tables: partner name, full address, shipment volumes, YoY growth, HS codes, product descriptions, and their own top counterparties. Great for supplier discovery without fetching every profile.

## `includeTradeLanes` (type: `boolean`):

Port-to-port lane rollups for the target: exit port, entry port + region, shipment count, weight, TEU, and estimated freight cost per lane.

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

Leave empty for a fresh crawl. To continue a run that stopped at `maxItems` (or was aborted after truncation), paste the `resumeCursor` from that run's OUTPUT — the crawl picks up exactly where it stopped and you are not re-charged for records already delivered.

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

Hard cap on total records emitted across all targets and record types. When the cap truncates the run, a `resumeCursor` is written to the run OUTPUT so you can continue later.

## `maxConcurrency` (type: `integer`):

Maximum number of target pages fetched in parallel.

## `proxy` (type: `object`):

ImportYeti sits behind Cloudflare and blocks datacenter IPs — residential US proxies are required and enabled by default.

## `maxUnblockerRequests` (type: `integer`):

Per-run cap on paid Cloudflare-bypass (scrape.do) calls used after the free proxy lanes fail. Applies to paying users only. 0 disables the paid fallback.

## Actor input object example

```json
{
  "companies": [
    "apple"
  ],
  "locationType": "supplier",
  "includeBols": true,
  "includeSummary": true,
  "includeTopPartners": false,
  "includeTradeLanes": false,
  "maxItems": 1000,
  "maxConcurrency": 10,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "maxUnblockerRequests": 40
}
```

# 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 = {
    "companies": [
        "apple"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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 = {
    "companies": ["apple"],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/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 '{
  "companies": [
    "apple"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call memo23/importyeti-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ImportYeti: Bills of Lading, Suppliers, HS Codes & Trade Lanes",
        "description": "Map any company's US import supply chain: 50 recent bills of lading per target plus supplier league tables, HS-code breakdowns and port-to-port trade lanes. Covers company, supplier, HS-code and country targets in one actor. Resumable runs — never pay twice for the same record.",
        "version": "0.0",
        "x-build-id": "bmQz61HWcVnra76Eh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~importyeti-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-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/memo23~importyeti-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-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/memo23~importyeti-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-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": {
                    "companies": {
                        "title": "US Importers (consignees)",
                        "type": "array",
                        "description": "ImportYeti company slugs or URLs for US importers. Examples: `apple`, `walmart`, `/company/costco`, or `https://www.importyeti.com/company/apple`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "suppliers": {
                        "title": "Foreign Suppliers (shippers)",
                        "type": "array",
                        "description": "ImportYeti supplier slugs or URLs for foreign shippers. Examples: `foxconn-interconnect-technology` or `https://www.importyeti.com/supplier/foxconn-interconnect-technology`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "hsCodes": {
                        "title": "HS Codes",
                        "type": "array",
                        "description": "HS codes: 2-digit chapter (`84`), 4-digit heading (`8471`), or 6-digit subheading (`847130`). Full `/hs-codes/...` URLs also work. Each code yields the most recent shipments plus top importers and suppliers for that code.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Country / Location Directories",
                        "type": "array",
                        "description": "Country slugs (`china`, `vietnam`, `india`) or full ImportYeti location URLs (e.g. `https://www.importyeti.com/location/supplier/china/country`, state/county/city URLs work too). Bare slugs use the directory type selected below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationType": {
                        "title": "Directory type for bare country slugs",
                        "enum": [
                            "supplier",
                            "company"
                        ],
                        "type": "string",
                        "description": "Whether bare `locations` slugs point at the foreign-supplier directory or the US-importer directory. Ignored for full location URLs, which already contain the type.",
                        "default": "supplier"
                    },
                    "startUrls": {
                        "title": "Any ImportYeti URLs (auto-classified)",
                        "type": "array",
                        "description": "Catch-all list: any importyeti.com company, supplier, HS-code, location, or product-tag (`/tags/...`) URL. Mixed types are fine — each URL is classified automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeBols": {
                        "title": "Bill-of-lading rows (up to 50 per target)",
                        "type": "boolean",
                        "description": "Per-shipment rows: arrival date, house/master BOL numbers, carrier SCAC, counterparty name + full address, weight, quantity, containers, product description, shipping route, and estimated freight cost.",
                        "default": true
                    },
                    "includeSummary": {
                        "title": "Summary record (1 per target)",
                        "type": "boolean",
                        "description": "Target-level rollup: total shipments, first/most-recent shipment dates, HS-code breakdown, top carriers, website, aliases, bill-type split, and UFLPA flag.",
                        "default": true
                    },
                    "includeTopPartners": {
                        "title": "Top-partner records (up to 50 per target)",
                        "type": "boolean",
                        "description": "The Top Suppliers / Top Companies tables: partner name, full address, shipment volumes, YoY growth, HS codes, product descriptions, and their own top counterparties. Great for supplier discovery without fetching every profile.",
                        "default": false
                    },
                    "includeTradeLanes": {
                        "title": "Trade-lane records",
                        "type": "boolean",
                        "description": "Port-to-port lane rollups for the target: exit port, entry port + region, shipment count, weight, TEU, and estimated freight cost per lane.",
                        "default": false
                    },
                    "resumeCursor": {
                        "title": "Resume cursor (continue a previous run)",
                        "type": "string",
                        "description": "Leave empty for a fresh crawl. To continue a run that stopped at `maxItems` (or was aborted after truncation), paste the `resumeCursor` from that run's OUTPUT — the crawl picks up exactly where it stopped and you are not re-charged for records already delivered."
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on total records emitted across all targets and record types. When the cap truncates the run, a `resumeCursor` is written to the run OUTPUT so you can continue later.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of target pages fetched in parallel.",
                        "default": 10
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "ImportYeti sits behind Cloudflare and blocks datacenter IPs — residential US proxies are required and enabled by default.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    },
                    "maxUnblockerRequests": {
                        "title": "Max paid-unblocker requests (paying users)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Per-run cap on paid Cloudflare-bypass (scrape.do) calls used after the free proxy lanes fail. Applies to paying users only. 0 disables the paid fallback.",
                        "default": 40
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
