# ImportYeti Scraper — US Customs Bill of Lading & Supplier Data (`logiover/importyeti-scraper`) Actor

Scrape US customs bill-of-lading & supplier trade data by company, supplier, product or HS code. Extract per-shipment BOL records with importer & supplier names, addresses, countries, products, weights and contacts. Keyless, no login.

- **URL**: https://apify.com/logiover/importyeti-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Lead generation
- **Features:** Limited permissions
- **Stats:** 25 total users, 6 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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 — US Customs Bill of Lading & Supplier Data

Extract **US customs bill-of-lading (BOL) shipment records** and **supplier trade relationships** from ImportYeti by company, supplier, product or HS code — one clean row per shipment, with importer **and** supplier addresses, countries, websites and contact enrichment. No API key, no login.

### What does ImportYeti Scraper do?

This Actor turns ImportYeti's public web front-end into a structured, shipment-level trade-intelligence feed. It loads company and supplier profile pages through a Chrome-fingerprinted HTTP client over US residential exits (needed to pass ImportYeti's Cloudflare Managed Challenge), then reassembles the streamed Next.js RSC payload embedded in each page and parses out the bill-of-lading records and supplier tables.

Unlike other ImportYeti tools that only return a company **summary**, this scraper emits **one row per bill of lading** — the actual shipment manifests reported to US Customs (CBP) — and then fans out across the importer↔supplier graph so a single run accumulates hundreds to thousands of shipments. Every profile embeds up to 50 recent bills of lading; the crawler walks each importer's suppliers (and each supplier's buyers) to keep collecting until your `maxResults` or a ~4-minute time budget is reached. It is fully keyless — you never supply an ImportYeti account or paid API key.

### Who is it for?

- **Sales & lead-gen teams** building lists of US importers (or the overseas factories behind them) in a niche.
- **Sourcing & procurement managers** discovering which suppliers a competitor buys from and at what volume.
- **Market & competitive analysts** mapping trade lanes, product mixes and shipment cadence.
- **Freight forwarders & logistics providers** prospecting shippers/consignees on specific lanes and HS codes.
- **Data teams & researchers** who need a clean, structured BOL dataset for enrichment, scoring or ML.

### Use cases

- Pull every recent shipment for a target importer and see exactly which suppliers, products and container volumes are behind it.
- Reverse a factory: start from a foreign supplier and list all the US companies it ships to — a ready-made prospect list.
- Filter a whole trade graph down to one product or HS code (e.g. furniture `9403`, LED lighting) and export only matching bills of lading.
- Benchmark a competitor's supply chain — total shipments, estimated shipping spend, top suppliers and product breakdown.
- Feed BOL rows into a CRM or spreadsheet as sourcing leads, enriched with importer and supplier address + country.

### Why use ImportYeti Scraper?

- **Bill-of-lading level output** — one row per shipment (BOL #, master/house BOL, arrival date, product, weight, quantity, containers, estimated cost), not just a company summary. This is the core differentiator.
- **Importer AND supplier in every row** — names, addresses, countries, websites and any available contact emails/phones for both sides of the shipment.
- **Product / HS-code fan-out** — crawl the graph and keep only shipments matching a keyword or Harmonized System code.
- **Keyless** — no ImportYeti login, no paid IYApiKey, no cookies. Just run it.
- **High volume by design** — graph crawl across importers and suppliers yields hundreds–thousands of rows per run, bounded by `maxResults`.
- **Export anywhere** — results stream to a dataset you can download as JSON, CSV, Excel or feed via API, and pay only per result.

### What data can you extract?

Each **shipment (bill of lading)** row contains the fields below. Company-summary rows (optional) add also-known names, HS codes, top suppliers and totals.

| Field | Type | Description |
|---|---|---|
| `_mode` | string | Which mode produced the row (`companySearch`, `supplierSearch`, `companyShipments`, `productSearch`). |
| `bol_number` | string | Bill-of-lading number reported to US Customs. |
| `bol_type` | string | `Master`, `House` or the raw bill code. |
| `master_bol` | string | Master bill-of-lading number (carrier level). |
| `house_bol` | string | House bill-of-lading number (forwarder level). |
| `arrival_date` | string (date) | Shipment arrival date (`YYYY-MM-DD`). |
| `company_name` | string | Importer / consignee (the US buyer). |
| `company_address` | string | Importer address. |
| `company_country` | string | Importer country. |
| `company_website` | string | Importer website when known. |
| `company_slug` | string | ImportYeti profile slug for the importer. |
| `company_total_shipments` | number | Total shipments on the importer's profile. |
| `company_emails` | array | Importer contact emails when available on the public profile. |
| `company_phones` | array | Importer contact phones when available on the public profile. |
| `supplier_name` | string | Supplier / shipper (the overseas manufacturer or exporter). |
| `supplier_address` | string | Supplier address. |
| `supplier_country` | string | Supplier country. |
| `supplier_website` | string | Supplier website when known. |
| `supplier_slug` | string | ImportYeti profile slug for the supplier. |
| `supplier_total_shipments` | number | Total shipments on the supplier's profile. |
| `supplier_emails` | array | Supplier contact emails when available on the public profile. |
| `supplier_phones` | array | Supplier contact phones when available on the public profile. |
| `product_description` | string | Goods description from the manifest. |
| `hs_code` | string | HS/HTS code parsed from the manifest when present. |
| `weight` | number | Shipment weight in kilograms. |
| `weight_unit` | string | Weight unit (`kg`). |
| `quantity` | number | Quantity shipped. |
| `quantity_unit` | string | Quantity unit (e.g. `CTN`, `PKG`). |
| `containers_count` | number | Number of containers on the bill of lading. |
| `shipping_cost_usd` | number | ImportYeti's estimated shipping cost (USD), when available. |
| `shipping_route` | string | Trade lane / route label. |
| `source_profile` | string | The profile slug this BOL was read from. |
| `source_profile_type` | string | `company` or `supplier`. |
| `profile_url` | string | ImportYeti URL of the source profile. |
| `scrapedAt` | string (date-time) | When the row was scraped. |

#### Example shipment output

```json
{
  "_mode": "companySearch",
  "bol_number": "FMALF142702",
  "bol_type": "House",
  "master_bol": "ONEYRTME32279600",
  "house_bol": "FMALF142702",
  "arrival_date": "2024-11-23",
  "company_name": "Nike",
  "company_address": "1 Bowerman Dr, Beaverton, Or 97005, Us",
  "company_country": "United States of America",
  "company_website": null,
  "company_slug": "nike",
  "company_total_shipments": 560,
  "company_emails": [],
  "company_phones": [],
  "supplier_name": "Stadium Grow Lighting B V",
  "supplier_address": "Abr Kroesweg 44",
  "supplier_country": "Netherlands",
  "supplier_website": null,
  "supplier_slug": "stadium-grow-lighting-b-v",
  "supplier_total_shipments": null,
  "product_description": "Sgl Mobile Unit Type Led Serial Commercial",
  "hs_code": null,
  "weight": 1536,
  "weight_unit": "kg",
  "quantity": 2,
  "quantity_unit": "PKG",
  "containers_count": 1,
  "shipping_cost_usd": 3098.38,
  "shipping_route": "Eu,Transatlantic",
  "source_profile": "nike",
  "source_profile_type": "company",
  "profile_url": "https://www.importyeti.com/company/nike",
  "scrapedAt": "2026-07-24T09:00:00.000Z"
}
```

### How to use

#### Option A — by company or supplier (most common)

1. Set **Mode** to `companySearch` (importers) or `supplierSearch` (foreign suppliers).
2. Put a name, slug or ImportYeti URL in **Company / supplier / product** (or the dedicated slug fields), e.g. `nike` or `https://www.importyeti.com/company/nike`.
3. Set **Max results** (e.g. 1000) and run. The Actor pulls that profile's bills of lading, then crawls its trade partners for more.

```json
{
  "mode": "companySearch",
  "companySlug": "nike",
  "maxResults": 1000
}
```

#### Option B — by product / HS code

1. Set **Mode** to `productSearch`.
2. Put a product keyword in **Company / supplier / product** (e.g. `furniture`) and/or an **HS / HTS code** (e.g. `9403`).
3. Optionally seed the crawl with a relevant importer via **Company slug**. Run — only matching bills of lading are kept.

```json
{
  "mode": "productSearch",
  "query": "furniture",
  "hsCode": "9403",
  "companySlug": "wayfair",
  "maxResults": 500
}
```

#### Precise, no crawl

Use `companyShipments` with exact `companySlugs` / `supplierSlugs` to grab just those profiles' bills of lading (up to 50 per profile) without expanding to neighbours.

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string (select) | `companySearch` | `companySearch`, `supplierSearch`, `companyShipments` or `productSearch`. |
| `query` | string | `furniture` | Free-text seed: company/supplier name, slug, URL, or product keyword (productSearch). |
| `companySlug` | string | — | Single importer slug or URL. |
| `companySlugs` | array | `[]` | Several importer slugs/URLs (one per line). |
| `supplierSlug` | string | — | Single supplier slug or URL. |
| `supplierSlugs` | array | `[]` | Several supplier slugs/URLs. |
| `hsCode` | string | — | HS/HTS code filter for productSearch. |
| `includeCompanySummary` | boolean | `true` | Also emit one company-summary row per crawled profile. |
| `maxResults` | integer | `500` | Upper bound on rows; drives crawl depth. |
| `proxy` | object | US RESIDENTIAL | Proxy config. US residential is required to pass Cloudflare. |

Full input example:

```json
{
  "mode": "companySearch",
  "query": "furniture",
  "companySlug": "wayfair",
  "companySlugs": [],
  "supplierSlug": "",
  "supplierSlugs": [],
  "hsCode": "",
  "includeCompanySummary": true,
  "maxResults": 1000,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US" }
}
```

### Output example

See the fully-populated shipment JSON in [What data can you extract?](#what-data-can-you-extract) above. Company-summary rows (when enabled) look like:

```json
{
  "_mode": "companySearch",
  "_row": "summary",
  "slug": "nike",
  "kind": "company",
  "company_name": "Nike",
  "also_known_names": ["Nike Usa", "Nike Inc", "Nike Retail Services"],
  "company_address": "1 Bowerman Dr, Beaverton, Or 97005, Us",
  "company_country": "United States of America",
  "company_website": null,
  "company_phone": null,
  "total_shipments": 560,
  "total_shipping_cost_usd": 2122157.77,
  "contact_emails": [],
  "contact_phones": [],
  "hs_codes": [{ "hs_code": "6110.20.2069", "description": "Other (338)", "shipments": 30 }],
  "top_suppliers": [{ "name": "Pou Sung Vietnam", "country": "Vietnam", "slug": "pou-sung-vietnam", "shipments": 189, "weight": 584921, "teus": 86 }],
  "supplier_count": 50,
  "bol_sample_count": 50,
  "profile_url": "https://www.importyeti.com/company/nike"
}
```

### Tips for best results

- **Start from a known slug or URL** — the slug is the last path segment of an ImportYeti profile URL (`/company/<slug>` or `/supplier/<slug>`). Names are auto-slugified but exact slugs are most reliable.
- **Raise `maxResults` to go deeper** — the crawler visits more profiles as the limit grows; 500 is fast, 2000+ maps a broad supply chain.
- **Use `companyShipments` for precision** when you only want a handful of named profiles and no graph expansion.
- **Combine keyword + HS code** in productSearch to tightly scope a product category.
- **Keep the US residential proxy on** — ImportYeti's Cloudflare challenge blocks datacenter and non-US exits; the default is already correct.
- **Contact enrichment is best-effort** — ImportYeti masks most emails/phones on its public pages, so those arrays are often empty; addresses, countries and websites are the dependable contact signals.
- **De-dupe across runs** on `bol_number` if you schedule the Actor, since profiles refresh over time.
- **Batch seeds** with the array fields to cover several importers or suppliers in one run.
- **Watch the log** — it prints per-profile BOL counts and the live queue size so you can see the crawl fan out.
- **Mind the time budget** — very large crawls stop cleanly at ~4 minutes and push everything collected so far.

### Integrations

Connect ImportYeti Scraper to the rest of your stack with Apify's built-in integrations:

- **Google Sheets** — push BOL rows straight into a sheet for the sales team.
- **Slack** — notify a channel when a run finishes or a target supplier appears.
- **Zapier / Make** — trigger downstream automations on each new dataset.
- **Webhooks** — POST results to your own endpoint or CRM.
- **Schedule** — run daily/weekly to track a competitor's incoming shipments over time.

### API usage

Run the Actor and fetch results programmatically. Get your token from the Apify console.

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~importyeti-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "mode": "companySearch", "companySlug": "nike", "maxResults": 1000 }'
```

**Node.js (apify-client)**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('logiover/importyeti-scraper').call({
  mode: 'companySearch',
  companySlug: 'nike',
  maxResults: 1000,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python (apify-client)**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")

run = client.actor("logiover/importyeti-scraper").call(run_input={
    "mode": "companySearch",
    "companySlug": "nike",
    "maxResults": 1000,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Use with AI agents (MCP)

This Actor works as a tool for LLM agents via the Apify MCP server, so an assistant can pull live customs data on demand. Example prompt: *"Use the ImportYeti scraper to list the last 500 bills of lading for the importer `wayfair`, then summarize the top 5 suppliers by shipment count and their countries."* The agent calls the Actor, reads the dataset, and answers with structured trade intelligence.

### FAQ

#### Is ImportYeti Scraper keyless?

Yes. It never asks for an ImportYeti login, cookies or a paid API key. It reads the public web front-end over a US residential proxy.

#### What exactly is a "bill of lading" here?

A bill of lading is the shipping manifest filed with US Customs (CBP) for each ocean import. ImportYeti surfaces these publicly; this Actor returns one row per manifest with importer, supplier, product and logistics detail.

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

As many as `maxResults` allows. Each profile embeds up to 50 bills of lading, and the crawler fans out across suppliers and buyers, so 500–2000+ rows per run is typical. A ~4-minute time budget stops very large crawls gracefully.

#### Why do I need a US residential proxy?

ImportYeti is protected by a Cloudflare Managed Challenge that blocks datacenter IPs and non-US exits. A US residential proxy (the default) passes the challenge; the Actor also rotates to a fresh IP on each retry.

#### Why are some email/phone fields empty?

ImportYeti masks most contact emails and phone numbers on its public profile pages (e.g. `XXXXXXX453`). The Actor surfaces any that are actually exposed but does not fabricate them; company/supplier **addresses, countries and websites** are the reliable contact signals.

#### Can I filter by product or HS code?

Yes — use `productSearch` with a keyword and/or `hsCode`. Only bills of lading whose product description or HS code matches are kept.

#### How do I find a company or supplier slug?

It is the last segment of the ImportYeti URL: `https://www.importyeti.com/company/nike` → `nike`. You can paste the full URL too; the Actor extracts the slug.

#### What formats can I export?

Any Apify dataset format: JSON, CSV, Excel, XML, RSS, or via the API. Use the Shipments view for BOL detail and the Summary view for company profiles.

#### How fresh is the data?

It reflects ImportYeti's public profiles at scrape time. Schedule the Actor to track new shipments as they appear; de-dupe on `bol_number` across runs.

#### Does it work for both importers and exporters?

Yes. `companySearch` starts from US importers; `supplierSearch` starts from overseas suppliers/manufacturers. Every row carries both sides of the shipment regardless of the starting point.

#### Will empty input return data?

Yes. An empty run defaults to `companySearch` on a popular importer and returns bill-of-lading rows bounded by `maxResults`.

#### Is there a rate limit?

The Actor self-throttles with a small concurrency and delays, and retries the Cloudflare challenge with fresh IPs. Very large runs are naturally paced by the crawl and the time budget.

### Is it legal?

This Actor collects data that ImportYeti publishes on its public website, which itself originates from US Customs (CBP) bill-of-lading records — public trade records. Use it responsibly and in line with ImportYeti's Terms of Service and applicable law. Do not use scraped personal contact data for spam or in violation of privacy regulations (GDPR/CCPA) or anti-spam laws (CAN-SPAM). You are responsible for how you use the output; this tool is provided for legitimate market research, sourcing and lead-generation purposes.

This Actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by ImportYeti; ImportYeti and all other trademarks mentioned here are the property of their respective owners.

### 📝 Changelog

#### 2026-11-01

- Monthly health check (2026-11-01): a live run on the current build completed successfully and returned data. Input options, output fields and pricing are unchanged.
- README refreshed: independence disclaimer added.
- README refreshed: duplicate "Related scrapers" sections merged.

#### 2026-10-15

- Every request now has a hard time limit, so a proxy connection that stalls can no longer hold up the run or push it past its timeout.
- A run that reaches its maximum cost per run now stops cleanly with its results saved and a status message, instead of ending as aborted.
- A proxy group your account cannot use no longer stops the run at start-up; it falls back to the default Apify Proxy.
- Runs with a short timeout (API and AI-agent calls) now finish inside it with what they collected, instead of being cut off.
- Memory is managed within the run's own limit, which removes a rare out-of-memory crash on large pages.
- The prefilled example for `maxResults` is now 400 (was 500).
- The default used when the field is left out for `maxResults` is now 8,000 (was 500).

#### 2026-09-23

- Fleet-wide quality audit. Verified end to end against live data and re-checked the input schema, the output columns and the run configuration.
- Output verified on a live run: 35 columns returned, 74.1% of cells populated.
- Run reliability reviewed: 100.0% of public runs succeeded in the last 30 days.
- Input schema, output schema and pricing configuration reviewed.
- Noted that 8 column(s) came back empty in this sample (`company_website`, `company_emails`, `company_phones`, `supplier_website`, `supplier_total_shipments`, `supplier_emails` and others); these are under review.

#### 2026-09-01

- Fleet-wide health check. Verified against this Actor's real run history: 30-day success rate, output row counts, per-field fill rates, and peak memory against the configured memory limit.
- Reviewed for the failure patterns that have cost this fleet runs — unguarded proxy setup, retry loops that can outlast the run's own time budget, and full-page HTML parsing that can exhaust a small container.
- No change to input, output fields or scraping logic.

#### 2026-08-11

- Maintenance release: refreshed the build and dependencies.
- Re-verified live execution, non-empty structured output and dataset field/type integrity.
- Reviewed reliability (retries, pagination) and output quality as part of a full-fleet QA pass.

#### 2026-08-01

- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.
- Declared 35 dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder.
- Declared 35 nullable dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder or brittle to sparse modes.

***

\*Maintained: last verified 2026-11-01 — checked end-to-end against live run history (reliability, output fields and types, and time/memory budgets).

***

### Pricing

This Actor is **pay per result**: you are charged for the rows it writes to your dataset, not for the time it spends running. There are no platform fees to calculate on top, and higher Apify plans pay a lower rate per result. A run that returns nothing costs nothing.

### Related scrapers

Other Actors from the same collection:

- [LEI](https://apify.com/logiover/gleif-lei-company-registry-scraper)
- [B2B Lead](https://apify.com/logiover/b2b-lead-scraper)
- [UK Companies House Bulk](https://apify.com/logiover/uk-companies-house-bulk-scraper)
- [LinkedIn Company](https://apify.com/logiover/linkedin-company-scraper)

# Changelog

This Actor's version history is a separate document: https://apify.com/logiover/importyeti-scraper/changelog.md

# Actor input Schema

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

What to scrape.

• **companySearch** — start from an importer (US buyer) and pull every bill of lading on its profile, then crawl its suppliers for thousands more shipments (highest volume)
• **supplierSearch** — start from a foreign supplier/manufacturer and pull its shipments + the US companies it ships to
• **companyShipments** — bills of lading for the exact company/supplier profile(s) you name, with no graph crawl (fast, precise)
• **productSearch** — crawl the trade graph and keep only shipments whose product description or HS code matches your keyword

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

Free-text seed. A company or supplier name (e.g. `Nike`), an ImportYeti profile URL, a profile slug (e.g. `nike`), or — in productSearch — a product keyword (e.g. `furniture`, `led lighting`). Leave empty for a broad default.

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

A single importer profile — its ImportYeti slug (e.g. `nike`) or full URL (`https://www.importyeti.com/company/nike`). Used by companySearch, companyShipments and productSearch (as the crawl seed).

## `companySlugs` (type: `array`):

Several importer profiles at once (slugs or URLs). One per line.

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

A single foreign supplier profile — slug (e.g. `pou-sung-vietnam`) or full URL (`https://www.importyeti.com/supplier/pou-sung-vietnam`). Used by supplierSearch and companyShipments.

## `supplierSlugs` (type: `array`):

Several supplier profiles at once (slugs or URLs). One per line.

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

Optional Harmonized System code to filter shipments (any length prefix, e.g. `9403` for furniture, `6110` for sweaters). Combined with the product keyword.

## `includeCompanySummary` (type: `boolean`):

When on, each crawled profile also yields one company-summary row (also-known names, HS codes, top suppliers, totals) alongside its per-shipment rows. Turn off for pure BOL output.

## `maxResults` (type: `integer`):

Upper bound on rows returned. Drives how far the graph crawl fans out. A single profile embeds up to 50 bills of lading, so the crawler visits more profiles until this many rows are collected (or the ~4-minute time budget is hit).

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

ImportYeti sits behind a Cloudflare Managed Challenge; a US RESIDENTIAL proxy is required to pass it (the default already does). Do not force the DATACENTER group.

## Actor input object example

```json
{
  "mode": "companySearch",
  "query": "furniture",
  "companySlug": "nike",
  "companySlugs": [],
  "supplierSlug": "pou-sung-vietnam",
  "supplierSlugs": [],
  "hsCode": "9403",
  "includeCompanySummary": true,
  "maxResults": 400,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Full results dataset. Use the Shipments view for bill-of-lading rows and the Summary view for company profiles.

# 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 = {
    "mode": "companySearch",
    "query": "furniture",
    "maxResults": 400,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,logiover/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/OOY1svfN9FkzthW8N/builds/hsBqcANs2ILQwapXt/openapi.json