# ImportYeti Scraper \[$1.2/1K💰] | Import Data | Suppliers | BOL (`ahmed_jasarevic/importyeti-scraper`) Actor

Scrape ImportYeti for US customs bill-of-lading trade data — importer and supplier profiles with shipment counts, trading partners, HS codes, ocean lanes, trademarks, contacts and recent bills of lading. Built for sourcing, procurement and import-export lead generation. $1.20 per 1,000 profiles.

- **URL**: https://apify.com/ahmed_jasarevic/importyeti-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.10 / 1,000 profiles

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## ImportYeti Scraper

Scrape **ImportYeti** US customs and bill-of-lading trade data — importer and supplier profiles with shipment counts, top trading partners, HS-code chapters, SCAC carrier codes, ocean lanes, trademarks, contacts and recent bills of lading, pushed to two structured datasets.

Built for sourcing and procurement teams, supply-chain analysts, trade-intelligence products and sales teams doing import-based lead generation.

### Find Suppliers and Track Competitor Imports From US Customs Data

- **Supplier sourcing & verification** — find overseas manufacturers by product, trademark or company name, ranked by how much they actually ship.
- **Competitor import monitoring** — track which suppliers your competitors buy from, how often they ship and which HS codes they import.
- **Import-export lead generation** — build lists of active US importers with addresses, geo coordinates, shipment volumes and contact records.
- **Trade intelligence datasets** — combine company rollups with row-level bills of lading (dates, BOL numbers, partners, weights, containers, routes).
- **Lane and carrier analysis** — ocean lanes (exit/entry ports), SCAC carrier codes, container types and CIF-valued shipments per company.
- **CRM enrichment** — feed importer/supplier profiles into Salesforce, HubSpot or a data warehouse on a schedule.

### How It Works

![How the ImportYeti Scraper works: company searches become importer profiles and bill-of-lading rows with trade partners.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-importyeti.webp)

The Actor queries ImportYeti's public search JSON for ten profiles per page, then parses the structured company payload embedded in each profile page. Requests are paced and sessions rotated to stay under the site's rate limits.

Profiles land in the default dataset with shipment totals, partners, HS codes, ocean lanes and contacts; bills of lading land in a separate shipments dataset. Use both to map supplier relationships and sourcing exposure.

ImportYeti is a Next.js site; no browser is ever launched. The Actor reads two structured JSON surfaces:

1. **Search — public JSON endpoint.** `GET https://www.importyeti.com/api/search?q=<query>&page=<N>` returns 10 profiles per page (name, type, country, address, shipment counts, URL) plus total pages and hits.
2. **Profile — structured payload embedded in the page HTML.** Each company/supplier page embeds its full data object (partners, HS codes, SCAC codes, lanes, trademarks, tags, contacts, bills of lading) in the served HTML. The Actor parses that object directly.

HTTP-only requests carry a browser-like TLS fingerprint and HTTP/2 headers, which ImportYeti accepts without any interactive check. ImportYeti answers burst traffic with HTTP 429/403 after roughly 25 requests per IP, so the Actor paces requests automatically and the **Proxy configuration** input (recommended for runs above ~25 requests) rotates IPs; sessions are retired every 20 requests so retries land on a fresh IP.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `searchQueries` | array | No | `["Patagonia"]` | Company names, supplier names, trademarks or product keywords. Each query is paginated through the search endpoint up to the per-query cap. |
| `startUrls` | array | No | `[]` | Direct profile URLs (`/company/{slug}` or `/supplier/{slug}`) — scraped without a search step. |
| `maxResultsPerQuery` | integer | No | `10` | Max profiles per search query (max 500; the search endpoint serves 10 per page). |
| `typeFilter` | select | No | `both` | `both`, `company` (US importers) or `supplier` (overseas suppliers). |
| `countryCode` | string | No | — | ISO-3166-1 alpha-2 code (e.g. `VN`, `CN`) to keep only profiles registered in that country. |
| `minShipments` | integer | No | `0` | Drop profiles with fewer lifetime bills of lading. Filters out inactive companies. |
| `enrichProfile` | boolean | No | `true` | Fetch each profile for full rollups. `false` = fast search-card rows only. |
| `maxShipmentsPerProfile` | integer | No | `10` | Recent bills of lading kept per profile (max 50). |
| `maxConcurrency` | integer | No | `2` | Parallel requests (1–10). Keep low — burst traffic triggers 429/403. |
| `requestsPerMinute` | integer | No | `0` | Crawl-wide throttle. `0` = auto: 15/min direct, 60/min with a proxy. |
| `proxy` | object | No | — | Standard Apify proxy picker. Recommended for runs above ~25 requests. |

### Output Fields

One row per company/supplier profile in the **default dataset**:

| Group | Fields |
| --- | --- |
| Identity | `name`, `slug`, `recordType` (`importer` / `supplier`), `type`, `profileUrl` |
| Location | `country`, `countryCode`, `address`, `addressParts`, `geo` (lat/long) |
| Activity | `totalShipments`, `shipments12m`, `firstShipmentDate`, `mostRecentShipment`, `otherAddressesCount`, `otherNamesCount`, `alsoKnownNames` |
| Trading partners | `topTradingPartners` (name, country, address, shipments, 12-month shipments, weight, TEUs, HS codes, product text, profile URL, top companies); also exposed as `topSuppliers` (for importers) / `topBuyers` (for suppliers) |
| Trade profile | `topHsCodes` (HS chapters with nested subheadings), `topScacCodes` (carriers with SCAC code, service types, year-over-year), `carriersPerCountry`, `oceanLanes` (exit/entry ports, shipments, weight, TEU, cost), `containerTypes` |
| Marks | `trademarks`, `tags` |
| Contacts | `contacts.phoneNumber`, `contacts.corporateInfo`, `contacts.phoneNumbers[]` (display number + `searchNumbers`) |
| Timing | `scrapedAt` |

Every bill of lading is also written to a separate **`shipments`** dataset (the `shipments` storage alias) — one row per shipment: `companyName`, `companySlug`, `companyProfileUrl`, `recordType`, `sourceQuery`, `shipmentType` (`bol` or `cif`), `date`, `billOfLading`, `masterBillOfLading`, `partnerName`, `weightKg`, `containers`, `description`, and for CIF rows the declared value fields.

Both datasets appear in the run's **Output** tab and can be exported as JSON/CSV/Excel from the **Storage** tab or via the API with each run's dataset IDs.

### Example Input

```json
{
  "searchQueries": ["Patagonia", "lithium battery"],
  "maxResultsPerQuery": 20,
  "typeFilter": "both",
  "countryCode": "",
  "minShipments": 5,
  "enrichProfile": true,
  "maxShipmentsPerProfile": 10,
  "requestsPerMinute": 0
}
```

Direct profile mode (no search step):

```json
{
  "startUrls": [{ "url": "https://www.importyeti.com/company/patagonia" }],
  "enrichProfile": true
}
```

### Example Output

Default dataset (trimmed):

```json
{
  "name": "Patagonia",
  "slug": "patagonia",
  "recordType": "importer",
  "country": "United States of America",
  "countryCode": "US",
  "address": "259 W Santa Clara St, San Jose, Ca 95113, Us",
  "geo": { "lat": 37.25022, "long": -119.75126 },
  "totalShipments": 4007,
  "shipments12m": 566,
  "firstShipmentDate": "2015-01-26",
  "mostRecentShipment": "2026-10-08",
  "topTradingPartners": [
    {
      "name": "Hirdaramani International Export",
      "country": "Sri Lanka",
      "countryCode": "LK",
      "shipments": 468,
      "shipments12m": 65,
      "hsCodes": ["6110.30", "6203.42"],
      "profileUrl": "https://www.importyeti.com/supplier/hirdaramani-international-export"
    }
  ],
  "topHsCodes": [{ "hsCode": "61", "description": "Apparel - knitted", "shipments": 1908 }],
  "topScacCodes": [{ "scac": "EXDO", "name": "Expeditors International", "shipments": 2322 }],
  "oceanLanes": [{ "exitPort": "Vung Tau", "entryPort": "Oakland, Ca", "shipments": 537 }],
  "trademarks": [{ "name": "Patagonia", "trademarks_count": 306 }],
  "scrapedAt": "2026-10-17T00:00:00.000Z"
}
```

Shipments dataset (one row per bill of lading):

```json
{
  "companyName": "Patagonia",
  "companySlug": "patagonia",
  "companyProfileUrl": "https://www.importyeti.com/company/patagonia",
  "recordType": "importer",
  "sourceQuery": "Patagonia",
  "shipmentType": "bol",
  "date": "2026-10-08",
  "billOfLading": "EXLTSE00038271",
  "masterBillOfLading": "ONEYCMBG16772300",
  "partnerName": "Mas Capital Pvt Ltd",
  "weightKg": 8500,
  "containers": 1,
  "description": "Cap Cool Daily Shirt …"
}
```

### Automate Import Monitoring With Schedules & Webhooks

- **Schedule** a daily or weekly run on the same queries (e.g. your own brands plus competitor names) to keep a rolling import-activity dataset.
- **Webhooks** fire when a run finishes — push new supplier rows straight into a CRM, Slack channel or warehouse.
- **API** — start runs, poll status and download both datasets programmatically (`/v2/acts/{actorId}/runs` and the dataset endpoints).
- **Zapier / Make** connect the Actor's run-completion events to thousands of apps.
- Set a **maximum cost per run** in the input; the Actor stops cleanly when the budget is reached.

### Related Actors

Verified related actors on Apify that pair well with this one. All links point to real, publicly available actors.

- [US Customs Records & Import Trade Data Scraper — ImportYeti](https://apify.com/jungle_synthesizer/importyeti-bill-of-lading-scraper)
- [Bill Of Lading Scraper — No Login, $1.4/1k](https://apify.com/fortuitous_pirate/bill-of-lading-scraper)
- [ImportYeti Trade Data Scraper](https://apify.com/lulzasaur/importyeti-scraper)
- [Import Export Data API — ImportGenius Bill of Lading Shipments](https://apify.com/nabeelbaghoor/importgenius-bill-of-lading-shipments-api)
- [Bill Of Lading Scraper](https://apify.com/quarterly_jingo/bill-of-lading-scraper)

### Frequently Asked Questions

#### Does ImportYeti have an official API?

Yes — ImportYeti sells a paid REST API (versioned `/v1.0` endpoints under `data.importyeti.com`, authenticated with an `IYApiKey` header, documented at docs.importyeti.com) with per-plan record credits and sales-gated custom plans. This Actor uses ImportYeti's free public web surfaces instead — the same search JSON endpoint the website calls and the structured data embedded in its company/supplier pages — so you can start extracting trade data immediately, without an API key or a sales conversation.

#### How is this different from ImportGenius or Panjiva-style trade databases?

ImportGenius exposes an enterprise REST API included with Enterprise plans (Business plans can add it) covering 25+ countries; classic trade-data suites such as Panjiva are subscription products aimed at enterprises. ImportYeti's website is free with rate limits and centers on US (plus Mexico) customs and manifest records. This Actor turns that free public surface into structured, exportable datasets at pay-per-event pricing, with no subscription to the data source itself.

#### Can I get supplier contact details?

Partly. ImportYeti masks phone numbers and corporate info (website, industry, revenue, LinkedIn) for logged-out visitors; the Actor captures what the page publishes, including the masked display number and the `searchNumbers` values attached to each phone record. Treat contacts as leads to verify, not as guaranteed-direct dials.

#### Is ImportYeti data free?

The website is free to use and rate-limits at roughly 25 requests per IP. The official ImportYeti API is a paid add-on. This Actor charges only for results: `$1.20` per 1,000 enriched profiles plus `$1.50` per 1,000 shipment rows. Free Apify accounts get a capped preview of 10 profiles per run.

#### How much does a typical run cost?

100 enriched profiles with 10 bills of lading each: 100 × $0.0012 + 1,000 × $0.0015 = **$1.62**. Set a maximum cost per run in Apify Console and the Actor stops gracefully at the limit.

#### Can an AI agent call this Actor?

Yes. It runs through the Apify API and MCP server with JSON input; see the section below for a minimal call, the output field list and the operational rules an agent needs. See also [For AI Agents & LLM Apps](#for-ai-agents--llm-apps).

#### What are good ImportYeti alternatives for bulk trade data?

For programmatic access: this Actor (free-source scraping, pay per result), the official ImportYeti API (paid, per-plan credits), or the ImportGenius API (enterprise, sales-gated). Related Actors listed above cover ImportYeti and bill-of-lading sources directly.

### For AI Agents & LLM Apps

Returns structured US import/export trade data from ImportYeti: company/supplier profiles (shipment rollups, partners, HS/SCAC codes, lanes, trademarks, contacts) plus a row-per-shipment `shipments` dataset.

Minimal input (search mode, enriched profiles):

```json
{ "searchQueries": ["Patagonia"], "maxResultsPerQuery": 5 }
```

Variant input (direct profile mode, no search step):

```json
{ "startUrls": [{ "url": "https://www.importyeti.com/company/patagonia" }] }
```

Output fields — profiles: `name`, `slug`, `recordType`, `type`, `profileUrl`, `country`, `countryCode`, `address`, `addressParts`, `geo`, `totalShipments`, `shipments12m`, `firstShipmentDate`, `mostRecentShipment`, `otherAddressesCount`, `otherNamesCount`, `alsoKnownNames`, `topTradingPartners`, `topSuppliers`, `topBuyers`, `topHsCodes`, `topScacCodes`, `carriersPerCountry`, `oceanLanes`, `containerTypes`, `trademarks`, `tags`, `contacts`, `recentShipments`, `cifShipments`, `scrapedAt`. Shipments dataset: `companyName`, `companySlug`, `companyProfileUrl`, `recordType`, `sourceQuery`, `shipmentType`, `date`, `billOfLading`, `masterBillOfLading`, `partnerName`, `weightKg`, `containers`, `description`.

Behaviors an agent should know:

- `searchQueries` and `startUrls` are alternative entry points; either one (or both) may be supplied.
- `enrichProfile: true` (default) costs one extra request per profile; `false` returns search-card rows only (cheaper, fewer fields).
- `minShipments` and `countryCode` filter server-side before enrichment, so they reduce billed profiles.
- Default `maxResultsPerQuery` is 10; the source search endpoint serves 10 results per page.
- Free Apify accounts are capped at 10 profiles per run; paid accounts are not.
- Raise `requestsPerMinute` / `maxConcurrency` only together with a configured proxy; without one, ImportYeti answers bursts with 429/403.
- Contacts and corporate info are partially masked by the source for logged-out visitors; expect masked values.

Billing: pay per event — `$0.0012` per profile scraped, `$0.0015` per shipment row stored, plus a per-GB actor-start charge. Set `max total charge` on the run to cap spend.

### Legal & Compliance Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by ImportYeti or ImportYeti Inc. It accesses only publicly available pages on importyeti.com — no login, no authenticated areas and no interactive checks are circumvented; contacts and corporate info returned are whatever the site itself publishes to logged-out visitors. The underlying data is public US Customs bill-of-lading information. You are responsible for your own compliance with ImportYeti's Terms of Service and with applicable data-protection law (including GDPR where personal contact data is processed); where phone numbers or corporate contacts are present in the output, do not use them for unsolicited commercial outreach in violation of applicable law such as CAN-SPAM, GDPR or TCPA.

### SEO Keywords

importyeti scraper, importyeti api, importyeti alternative, us import data, import export data, bill of lading data, us customs data, importer database, supplier sourcing, find suppliers online, hs code data, shipment data, importgenius alternative, trade data scraper, trade data api, competitor import data, supplier verification, import lead generation

# Actor input Schema

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

Company names, supplier names, trademarks or product keywords (e.g. 'Patagonia', 'lithium battery', 'phone case'). Each query is sent to ImportYeti's public /api/search JSON endpoint and paginated up to 'Max results per query'.

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

Direct ImportYeti profile URLs (https://www.importyeti.com/company/{slug} or https://www.importyeti.com/supplier/{slug}). Each URL is scraped directly, without a search step.

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

Maximum number of profiles to return per search query. The search API returns 10 results per page; the actor paginates until this cap is reached or no more pages are available.

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

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

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

Optional ISO-3166-1 alpha-2 country code (e.g. 'US', 'CN', 'VN') to keep only profiles registered in that country. Leave empty for no country filter.

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

Drop profiles with fewer than this many lifetime bills of lading on file. Use to filter out inactive or tiny companies.

## `enrichProfile` (type: `boolean`):

When on (default), each profile is fetched and enriched with its full rollups: top trading partners, HS-code chapters, carriers/SCAC codes, ocean lanes, trademarks, tags, contacts and recent bills of lading. Turn off for fast, search-card-only rows.

## `maxShipmentsPerProfile` (type: `integer`):

How many of the most recent bills of lading to include per profile when enrichment is on. The profile page lists up to 50.

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

How many requests run in parallel. Keep this low (1-2): ImportYeti responds to request bursts with HTTP 429/403. Only raise it when a proxy is configured.

## `requestsPerMinute` (type: `integer`):

Throttle applied to the whole crawl to stay under ImportYeti's rate limit. 0 = auto: 15/min without a proxy, 60/min with a proxy (sessions rotate IPs every 20 requests).

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "searchQueries": [
    "Patagonia"
  ],
  "startUrls": [
    {
      "url": "https://www.importyeti.com/company/patagonia"
    }
  ],
  "maxResultsPerQuery": 10,
  "typeFilter": "both",
  "minShipments": 0,
  "enrichProfile": true,
  "maxShipmentsPerProfile": 10,
  "maxConcurrency": 2,
  "requestsPerMinute": 0,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per importer/supplier profile in the default dataset.

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

One row per bill of lading.

# 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"
        }
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/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" }],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/importyeti-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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"
    }
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/importyeti-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/importyeti-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/v5Gldtgm1DpMOjiG5/builds/xJyf9WJcDfBfFgRxv/openapi.json