# ImportYeti Scraper: Importers, Suppliers & Bills of Lading (`s-r/importyeti-scraper`) Actor

Extract ImportYeti company profiles, supplier and customer relationships, and recent US bills of lading. Discover companies by name or HS code and export structured records for sourcing and supply-chain research.

- **URL**: https://apify.com/s-r/importyeti-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** E-commerce, Lead generation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 company profiles

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/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

ImportYeti Scraper collects public US import company profiles, supplier and customer relationships, and recent bills of lading. Start with known companies or discover businesses by a search term or HS code. The output uses separate record types so sourcing teams, B2B researchers and supply-chain analysts can connect each company to its trading partners and shipments.

### What ImportYeti Scraper collects

A company record describes an importer or supplier as ImportYeti publishes it. It includes its name, address, country, website domain where available, total shipments, first and last shipment dates, HS code breakdown and port routes. Shipment totals describe the source profile; they do not mean that the actor exports that many individual bills of lading. The public profile exposes a limited recent shipment sample.

Counterparty records describe the business relationships attached to each profile. For an importer, counterparties are suppliers. For a supplier, counterparties are customers. Each relationship carries the parent company identifier, counterparty name, country and shipment count when the source provides them. Missing counterparties remain labeled as the source labels them; missing names, addresses or identifiers are never reconstructed from unrelated records.

Shipment records contain the recent bills of lading shown on the profile. They include bill number, arrival date, consignee and shipper information, weight in kilograms, quantity, quantity unit, container count and cargo description where available. This makes them useful for comparing recent supplier activity or joining a bill number to a separate container-tracking dataset.

### Input

Provide at least one of `companies`, `query` or `hsCode`. The `companies` array accepts full ImportYeti profile URLs, paths such as `supplier/zinus-global-indonesia`, or importer slugs such as `wal-mart`. Other websites are rejected. Explicit companies are processed first, then name-search discoveries, then HS-code discoveries. Duplicate profile identifiers are collected once within the collection.

```json
{
  "companies": ["supplier/rhonda-speaker"],
  "maxCompanies": 1,
  "includeCounterparties": true,
  "includeShipments": true
}
```

This input refers to a real public profile captured in the product's source fixtures. It illustrates requesting the company, its relationship and its recent shipment together. Current source results can change after the capture date.

Use `query` for a company name or search phrase. Set `searchType` to `company` for importers, `supplier` for suppliers, or `any` for both. This filter affects discoveries; it does not discard explicit profile inputs. Use `hsCode` for a four or six digit code, optionally writing a six digit code with a dot. HS discovery follows the public company tables associated with matching codes. Table rows without a linked profile cannot be enriched.

`maxCompanies` limits successfully collected profiles across the collection, from 1 to 500, with a default of 10. It does not limit the combined number of related records. `includeCounterparties` defaults to true; `maxCounterparties` defaults to 50 and can be reduced to zero. `includeShipments` defaults to false; enable it to collect up to `maxShipments` recent bills per company, with a maximum of 50. `includeTimeSeries` optionally adds the relationship shipment, weight and TEU history and may increase output size substantially.

### Output

Each dataset row has `record_type` and `_type`, both set to `company`, `counterparty` or `shipment`. All rows also contain `source`, a UTC `fetched_at` timestamp, a `row_id` and the parent `company_id`. Identifiers use the source profile path, for example `company/wal-mart`. They are source identifiers, not official company registration numbers.

Company records expose `name`, `role`, `country`, `address`, `domain`, `total_shipments`, `first_shipment_date`, `last_shipment_date`, `top_hs_codes` and `top_routes`. Counterparty records expose `counterparty_name`, `relation`, `counterparty_id`, `counterparty_country`, `shipments` and `hs_codes`. Shipment records expose `bill_of_lading`, `date`, `shipper_name`, `consignee_name`, `weight_kg`, `quantity`, `quantity_unit` and `containers`.

Dates are normalized to `YYYY-MM-DD`; HS codes contain digits without dots. Relationship first and last shipment dates reflect the source time-series keys, which can represent quarter starts. They should not be treated as exact individual bill dates. Domain values omit the scheme and leading `www` when the source provides a usable website.

### Coverage and continuation

The public source shows at most 50 counterparties and 50 recent bills per profile. This actor does not promise a complete historical shipment export. In particular, HS codes and loading or discharge ports are available in profile summaries but absent from individual recent bills. On shipment rows, `hs_code`, `port_of_loading`, `port_of_discharge` and `carrier_scac` stay null. The actor does not infer them from cargo descriptions or copy aggregate routes onto individual bills.

Larger collections are collected in several requests. Apify follows continuation automatically within its collection budget. Direct API users reuse the original input with `next_cursor` until it becomes null. Check `partial` and `warnings` before treating a collection as complete. An unavailable profile can produce a warning while other profiles are still delivered. A completely empty or unavailable search returns a structured error rather than an invented record.

### Pricing

Billing distinguishes company, counterparty and shipment rows. Only delivered rows count toward their corresponding result event. A run-start event may apply even when a valid search finds no records; consult the actor's live pricing panel for current event prices. Request fewer related rows or disable shipment collection when only company profiles are needed. Non-paying users receive at most 10 dataset rows per run, including all record types combined. This is a delivery cap, not a promise that billable records have no price.

### FAQ

#### Does this export every historical shipment?

No. It exports the recent bills visible on public company profiles. Historical totals and recent bill samples describe different source surfaces and should be analyzed separately.

#### Can I search by an HS code?

Yes. Supply `hsCode` with four or six digits. The actor finds matching public HS pages, follows linked importer or supplier profiles, and applies `maxCompanies` across the collection.

#### Why are some shipment fields null?

The recent-bill source does not publish every field available in commercial customs datasets. Missing HS codes, ports, carrier identifiers, masked contact details and unavailable counterparties remain missing or retain the source's masking.

#### Can records be joined to other datasets?

Yes. Use company identifiers inside this source, domains and business names for company matching, normalized HS codes for product classification, and bill numbers for shipment tracking. Verify ambiguous company-name matches before relying on them.

# Actor input Schema

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

ImportYeti company/supplier URLs, paths or bare importer slugs. Processed before search discoveries.

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

Company name or search term. At least one of companies, query or hsCode is required.

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

Four or six digit HS code; a six digit code may contain a dot, such as 8518.22. Discovers companies from the publicly shown HS tables.

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

Filter search discoveries to importers (company), suppliers or both. Explicit companies are always processed.

## `maxCompanies` (type: `integer`):

Maximum successfully collected company profiles across the complete cursor sequence, including explicit input and discoveries. Related rows are additional.

## `includeCounterparties` (type: `boolean`):

Include suppliers of importers or customers of suppliers, as separate counterparty rows.

## `maxCounterparties` (type: `integer`):

Maximum counterparty rows per company. The public source shows at most 50.

## `includeShipments` (type: `boolean`):

Include recent bills of lading as shipment rows. HS codes and ports are unavailable on these source rows and remain null.

## `maxShipments` (type: `integer`):

Maximum recent bills of lading per company, up to the public source limit of 50.

## `includeTimeSeries` (type: `boolean`):

Include the source relationship shipment/weight/TEU time series on each counterparty, keyed by YYYY-MM-DD. May substantially increase output size.

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

Opaque next_cursor from the previous response. Reuse all original input options unchanged. Omit for a new collection.

## Actor input object example

```json
{
  "companies": [
    "supplier/rhonda-speaker"
  ],
  "searchType": "any",
  "maxCompanies": 10,
  "includeCounterparties": true,
  "maxCounterparties": 50,
  "includeShipments": false,
  "maxShipments": 50,
  "includeTimeSeries": false
}
```

# Actor output Schema

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

No description

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

No description

# 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": [
        "supplier/rhonda-speaker"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/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": ["supplier/rhonda-speaker"] }

# Run the Actor and wait for it to finish
run = client.actor("s-r/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 '{
  "companies": [
    "supplier/rhonda-speaker"
  ]
}' |
apify call s-r/importyeti-scraper --silent --output-dataset

```

## MCP server setup

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