# Industrial Supplier & Import Intelligence (`scraping_scrap/industrial-supplier-import-intelligence`) Actor

Find industrial suppliers and import intelligence from ImportYeti, with best-effort ThomasNet and GlobalSpec checks. Export supplier profiles, shipment summaries, contacts, lead scores, and source health diagnostics.

- **URL**: https://apify.com/scraping\_scrap/industrial-supplier-import-intelligence.md
- **Developed by:** [Вадим Захаров](https://apify.com/scraping_scrap) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Industrial Supplier & Import Intelligence

Find industrial suppliers, manufacturers, and import-intelligence signals from public ThomasNet, GlobalSpec, and ImportYeti data. Export normalized supplier profiles with websites, public company-level contacts, categories, certifications, shipment summaries, lead scores, and source health diagnostics.

Use this Actor for supplier discovery, procurement research, B2B supplier leads, manufacturer finding, sourcing automation, and import intelligence workflows.

### What this Actor does

Industrial Supplier & Import Intelligence searches public industrial supplier and import-intelligence sources for a product, material, category, company type, or keyword. It normalizes supplier records into one Dataset schema, filters by country and lead score, deduplicates matching companies, optionally performs shallow website enrichment, writes final records to the default Dataset, and writes run summaries to the Key-Value Store.

The Actor is designed for public-data sourcing workflows. It does not use login-only pages, private APIs, private accounts, hidden authorization-only endpoints, authorization bypass, cookies, or CAPTCHA solving.

### Supported sources

- ThomasNet: supplier and manufacturer directory records.
- GlobalSpec: public supplier, product, and company listing signals.
- ImportYeti: public company and import/shipment summary signals.

ImportYeti is the currently live-confirmed source for Dataset records in Apify Cloud. ThomasNet and GlobalSpec are best-effort public sources and may return public 403/challenge responses; when that happens, the Actor records the block in `SUMMARY.sourceHealth` and `OUTPUT.sourceHealth` and continues with other usable sources.

### Public sources

The Actor uses public pages from ThomasNet, GlobalSpec, and ImportYeti. Source coverage depends on public availability, current layouts, blocking behavior, and whether a source publishes enough company, website, contact, country, or shipment data for the query.

### Data boundaries

This Actor uses only publicly available pages and public data. It does not use private APIs, login-only pages, account data, hidden authorization-only endpoints, authorization bypass, CAPTCHA solving, cookies, or private request headers. If a source blocks requests, rate-limits, changes layout, or requires login for deeper data, the Actor records the issue in `SUMMARY.sourceErrors` and `SUMMARY.sourceHealth`, then continues with remaining public data where possible.

### What data you get

Each Dataset item is a normalized supplier profile. Depending on public source coverage and input options, records can include:

- company name and normalized company name;
- stable `supplierFingerprint`;
- `primaryDomain` extracted from the supplier website;
- website URL;
- country metadata and country match status;
- region, city, and address when available;
- description;
- products, categories, and certifications;
- public company-level emails, phones, and social links;
- source IDs and source URLs;
- ImportYeti shipment summary;
- shallow website enrichment;
- lead score and lead score reasons;
- scrape timestamp.

### Inputs

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `query` | string | Required | Product category, material, company type, keyword, or supplier search term. Must contain non-whitespace text. |
| `sources` | string array | `["thomasnet", "globalspec", "importyeti"]` | Sources to run. Allowed values are `thomasnet`, `globalspec`, and `importyeti`. An empty array falls back to all sources. |
| `countries` | string array | `[]` | Optional country filter. Empty means all countries. Matching depends on source-provided country/location data and is best effort. |
| `maxResults` | integer | `100` | Maximum final records pushed after normalization, country filtering, deduplication, enrichment, scoring, score filtering, sorting, and final cap. |
| `includeContacts` | boolean | `true` | Include public company-level emails, phones, and social links when visible. Personal contact extraction is not part of this Actor. |
| `includeShipmentData` | boolean | `true` | Include ImportYeti public shipment summary fields when available. Shipment data is summary-only. |
| `includeWebsiteEnrichment` | boolean | `true` | Visit supplier websites for shallow enrichment from the homepage and likely contact/about pages. |
| `countryFilterMode` | string | `strict` | `strict` keeps only explicit country matches when `countries` is set. `lenient` keeps records with unknown country and drops only explicit mismatches. |
| `minLeadScore` | integer | `0` | Minimum lead score from 0 to 100. `0` disables score filtering. |
| `proxyConfiguration` | object | `{ "useApifyProxy": true }` | Standard Apify proxy configuration object. |
| `maxConcurrency` | integer | `5` | Maximum concurrency passed to source crawlers and enrichment workers. |

### Input examples

Use all supported sources with country filtering and website enrichment:

```json
{
  "query": "industrial valves",
  "sources": ["thomasnet", "globalspec", "importyeti"],
  "countries": ["United States", "Canada"],
  "maxResults": 50,
  "includeContacts": true,
  "includeShipmentData": true,
  "includeWebsiteEnrichment": true,
  "countryFilterMode": "strict",
  "minLeadScore": 25,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 5
}
````

Use ImportYeti for shipment-summary research:

```json
{
  "query": "stainless steel fittings",
  "sources": ["importyeti"],
  "countries": [],
  "maxResults": 25,
  "includeContacts": false,
  "includeShipmentData": true,
  "includeWebsiteEnrichment": false,
  "countryFilterMode": "lenient",
  "minLeadScore": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 3
}
```

### Example input: all sources

```json
{
  "query": "industrial valves",
  "sources": ["thomasnet", "globalspec", "importyeti"],
  "countries": ["United States", "Canada"],
  "maxResults": 50,
  "includeContacts": true,
  "includeShipmentData": true,
  "includeWebsiteEnrichment": true,
  "countryFilterMode": "strict",
  "minLeadScore": 25,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 5
}
```

### Example input: ImportYeti shipment research

```json
{
  "query": "stainless steel fittings",
  "sources": ["importyeti"],
  "countries": [],
  "maxResults": 25,
  "includeContacts": false,
  "includeShipmentData": true,
  "includeWebsiteEnrichment": false,
  "countryFilterMode": "lenient",
  "minLeadScore": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 3
}
```

### Output example

```json
{
  "companyName": "Acme Industrial Supplies Inc.",
  "normalizedCompanyName": "acme industrial supplies",
  "supplierFingerprint": "8a7f34d2e5c901ab",
  "primaryDomain": "example.com",
  "website": "https://www.example.com/",
  "country": "United States",
  "countryRaw": "United States",
  "countryNormalized": "United States",
  "countryIso2": "US",
  "countryMatchStatus": "matched",
  "region": "Ohio",
  "city": "Cleveland",
  "address": "123 Industrial Road, Cleveland, OH",
  "description": "Manufacturer of industrial valves and fittings.",
  "products": ["valves", "fittings", "pipe connectors"],
  "categories": ["Industrial Valves", "Fluid Handling"],
  "certifications": ["ISO 9001"],
  "emails": ["sales@example.com"],
  "phones": ["+1 555 123 4567"],
  "socialLinks": {
    "linkedin": "https://www.linkedin.com/company/example",
    "facebook": "",
    "twitter": "",
    "youtube": "",
    "instagram": ""
  },
  "source": "thomasnet",
  "sources": ["thomasnet", "globalspec"],
  "sourceUrls": ["https://www.thomasnet.com/example"],
  "shipmentSummary": {
    "hasRecentShipment": true,
    "lastShipmentDate": "2026-02-10",
    "shipmentCount": 124,
    "tradePartners": ["Example Trading Co."]
  },
  "websiteEnrichment": {
    "title": "Acme Industrial Supplies",
    "emails": ["sales@example.com"],
    "phones": ["+1 555 123 4567"],
    "socialLinks": {
      "linkedin": "https://www.linkedin.com/company/example"
    },
    "certifications": ["ISO 9001"],
    "pagesVisited": ["https://www.example.com/", "https://www.example.com/contact"]
  },
  "leadScore": 100,
  "leadScoreReasons": [
    "Has company website",
    "Has at least one email",
    "Has at least one phone",
    "Has at least one certification",
    "Has recent shipment signal",
    "Has 3 or more products/categories combined",
    "Appears in 2 or more selected sources"
  ],
  "scrapedAt": "2026-06-06T12:30:00.000Z"
}
```

### Dataset output

Each Dataset item is a normalized supplier record. Required fields are stable. Arrays are always arrays. Nullable fields use stable `null`, for example `countryIso2` is `null` when country is unknown. Raw HTML, raw debug payloads, cookies, tokens, session IDs, request headers, authorization data, and private payloads are not included in Dataset records.

```json
{
  "companyName": "Acme Industrial Supplies Inc.",
  "normalizedCompanyName": "acme industrial supplies",
  "supplierFingerprint": "8a7f34d2e5c901ab",
  "primaryDomain": "example.com",
  "website": "https://www.example.com/",
  "country": "United States",
  "countryRaw": "United States",
  "countryNormalized": "United States",
  "countryIso2": "US",
  "countryMatchStatus": "matched",
  "source": "thomasnet",
  "sources": ["thomasnet", "globalspec"],
  "sourceUrls": ["https://www.thomasnet.com/example"],
  "shipmentSummary": {
    "hasRecentShipment": true,
    "lastShipmentDate": "2026-02-10",
    "shipmentCount": 124,
    "tradePartners": ["Example Trading Co."]
  },
  "leadScore": 100,
  "leadScoreReasons": [
    "Has company website",
    "Has at least one email",
    "Has recent shipment signal"
  ],
  "scrapedAt": "2026-06-06T12:30:00.000Z"
}
```

When `includeContacts=false`, top-level `emails`, `phones`, and `socialLinks` are cleared and contact fields inside `websiteEnrichment` are also removed.

### Lead scoring

Lead score is a heuristic from 0 to 100. It is not a guarantee of supplier quality.

Current scoring signals:

- has company website;
- has at least one public company-level email, when `includeContacts=true`;
- has at least one public company-level phone, when `includeContacts=true`;
- has at least one certification;
- has recent shipment signal, when `includeShipmentData=true`;
- has 3 or more products/categories combined;
- appears in 2 or more selected sources.

`leadScoreReasons` explains which signals contributed to the score.

### Country filtering

The Actor keeps backward-compatible `country` text and also emits stronger country metadata:

- `countryRaw`
- `countryNormalized`
- `countryIso2`
- `countryMatchStatus`

Supported country aliases include common names and codes such as `US`, `USA`, `United States`, `UK`, `GB`, `Germany`, `DE`, `China`, and other common sourcing countries.

`countryFilterMode` controls behavior when `countries` is set:

- `strict`: keep only records that explicitly match the requested countries.
- `lenient`: keep explicit matches and records with unknown country, but drop explicit mismatches.

Country filtering depends on source-provided country/location data. If a source does not publish location data, strict filtering can remove otherwise useful suppliers.

### Website enrichment

When `includeWebsiteEnrichment=true`, the Actor visits supplier websites for shallow enrichment. It focuses on the homepage and a small set of likely contact/about pages.

Website enrichment can add:

- page title;
- public company-level emails;
- public company-level phones;
- public social links;
- certifications;
- `pagesVisited`.

Enrichment is bounded and safety-focused:

- no deep crawler;
- no login/private pages;
- no private network targets;
- no unsafe redirects;
- no CAPTCHA solving;
- errors are tolerated and do not remove the supplier record.

### Source health

The Actor writes per-source diagnostics in `SUMMARY.sourceHealth` and `OUTPUT.sourceHealth`.

Fields:

- `searchPagesFetched`
- `detailPagesQueued`
- `detailPagesFetched`
- `cardsParsed`
- `jsonLdRecordsParsed`
- `rawRecordsEmitted`
- `blockedPages`
- `httpStatus`
- `parseWarnings`
- `sourceConfidence`
- `sourceErrors`
- `elapsedMs`

Use source health to understand source coverage, parser quality, blocked pages, layout changes, and source-specific failures.
`httpStatus` is the most relevant observed HTTP status when one is available, otherwise `null`.
`sourceConfidence` is `high`, `medium`, or `low`; blocked/challenge-only sources are reported as `low`.

### Summary

The Actor writes a detailed run summary to the default Key-Value Store key `SUMMARY`.

```json
{
  "query": "industrial valves",
  "sourcesRequested": ["thomasnet", "globalspec", "importyeti"],
  "totalBySource": {
    "thomasnet": 42,
    "globalspec": 18,
    "importyeti": 25
  },
  "rawRecordsTotal": 85,
  "normalizedRecordsTotal": 85,
  "dedupedRecordsTotal": 64,
  "finalRecordsPushed": 50,
  "duplicatesRemoved": 21,
  "averageLeadScore": 67.4,
  "filteredOutByCountry": 6,
  "filteredOutByLeadScore": 8,
  "sourceErrors": {
    "thomasnet": [],
    "globalspec": [],
    "importyeti": []
  },
  "sourceHealth": {
    "thomasnet": {
      "searchPagesFetched": 1,
      "detailPagesQueued": 12,
      "detailPagesFetched": 12,
      "cardsParsed": 42,
      "jsonLdRecordsParsed": 3,
      "rawRecordsEmitted": 42,
      "blockedPages": 0,
      "httpStatus": 200,
      "parseWarnings": 0,
      "sourceConfidence": "high",
      "sourceErrors": [],
      "elapsedMs": 1240
    }
  },
  "startedAt": "2026-06-06T12:00:00.000Z",
  "finishedAt": "2026-06-06T12:05:00.000Z"
}
```

### OUTPUT

The Actor also writes a high-level Key-Value Store alias named `OUTPUT` for easier inspection in Apify Console.

```json
{
  "query": "industrial valves",
  "datasetId": "default-dataset-id",
  "keyValueStoreId": "default-key-value-store-id",
  "finalRecordsPushed": 50,
  "averageLeadScore": 67.4,
  "totalBySource": {
    "thomasnet": 42,
    "globalspec": 18,
    "importyeti": 25
  },
  "sourceHealth": {},
  "sourceErrors": {
    "thomasnet": [],
    "globalspec": [],
    "importyeti": []
  },
  "startedAt": "2026-06-06T12:00:00.000Z",
  "finishedAt": "2026-06-06T12:05:00.000Z"
}
```

### Live fixture workflow

Sanitized fixture excerpts live in `fixtures/live/*.sanitized.html` and `fixtures/live/*.sanitized.json`. They are intentionally small, do not contain private pages, cookies, session IDs, tokens, raw headers, or full archived third-party pages, and are used only by parser tests.

ImportYeti currently renders the search UI through a Next/React app and fetches public result data through a frontend JSON payload. Keep the HTML fixture for card-selector compatibility and the JSON fixture for the current search payload parser.

To save a new sanitized fixture from a local HTML file:

```bash
node scripts/save-live-fixtures.mjs --source thomasnet --input /path/to/source.html
```

To save a sanitized public JSON payload:

```bash
node scripts/save-live-fixtures.mjs --source importyeti --format json --name importyeti-search-api --input /path/to/search-response.json
```

To fetch and sanitize a public page directly:

```bash
node scripts/save-live-fixtures.mjs --source globalspec --url "https://www.globalspec.com/search/search?query=hydraulic%20pumps"
```

Review generated fixtures before committing them. Do not commit private, account-based, login-only, sensitive, or huge raw HTML.

### Apify live validation checklist

Run these queries before release validation:

- `industrial valves`
- `stainless steel fittings`
- `hydraulic pumps`
- `cnc machining`

For each query, validate this matrix:

- proxy on and proxy off;
- `maxResults` 50 and 100;
- `includeWebsiteEnrichment` true and false.

For every run, inspect:

- Dataset records include `supplierFingerprint`, `primaryDomain`, and country metadata.
- `SUMMARY.sourceHealth` has non-negative counts and elapsed times.
- `OUTPUT` is written and links the high-level run result to Dataset/KVS IDs.
- No private/login-only data, raw HTML, cookies, session IDs, request headers, or tokens appear in Dataset, `SUMMARY`, or `OUTPUT`.

### Limitations

- Public sources only.
- No login-only pages or private APIs.
- No cookies, accounts, or private request headers.
- No CAPTCHA solving.
- No deep website crawler.
- Shipment data is summary-only.
- Source coverage depends on public availability and current source layouts.
- Some sources may omit websites, contacts, or location data.
- Country filtering depends on source-provided country/location data.
- Website enrichment is shallow and may miss JavaScript-rendered content.
- `leadScore` is heuristic and not a supplier quality guarantee.

### FAQ

#### Is this a ThomasNet scraper?

Yes. It can search public ThomasNet supplier listings and normalize public supplier data into the shared Dataset schema.

#### Is this a GlobalSpec scraper?

Yes. It can parse public GlobalSpec listing signals when the pages are publicly accessible and not blocked.

#### Is this an ImportYeti scraper?

Yes. It can extract public ImportYeti company signals and summary-level shipment intelligence. It does not export full private shipment-row datasets.

#### Can I use it as a supplier finder?

Yes. It is designed as a supplier finder, industrial supplier scraper, manufacturer finder, B2B supplier leads tool, procurement research tool, sourcing automation workflow, and import intelligence helper.

#### Does it collect personal contacts?

No. Contact extraction is limited to public company-level emails, phones, and social links when visible.

#### Why are there few or zero records?

Try a broader `query`, enable more `sources`, lower `minLeadScore`, increase `maxResults`, switch `countryFilterMode` to `lenient`, or remove restrictive `countries` filters. Also inspect `SUMMARY.sourceErrors` and `SUMMARY.sourceHealth`.

#### Why does a source show blocked pages or parse warnings?

Public sites can rate-limit, block, change layout, or require JavaScript/login for deeper data. The Actor records these issues and continues where possible.

### Known limitations

- Source layout changes can reduce extraction quality until selectors are updated.
- Some sources may have missing websites or contact details in public listings.
- `countries` filtering depends on source-provided country/location data and may miss companies when location data is incomplete.
- Website enrichment is shallow and only visits the homepage plus a small set of likely contact/about pages.
- ImportYeti shipment data is summary-only; the Actor does not export full shipment-row datasets.

### Troubleshooting

- low results: broaden `query`, enable more `sources`, lower `minLeadScore`, increase `maxResults`, use `countryFilterMode: "lenient"`, or remove restrictive `countries` filters.
- blocked requests: keep proxy configuration enabled, lower `maxConcurrency`, and check `SUMMARY.sourceErrors` plus `SUMMARY.sourceHealth` for source-specific messages.
- missing contacts: verify `includeContacts` is true. Some public listings do not expose company-level emails or phones, and the Actor does not collect login-only or private data.
- empty country-filtered outputs: remove `countries` or try broader country names because empty country-filtered outputs often mean the source did not publish enough location data for those records.

### Search phrases

ThomasNet scraper, GlobalSpec scraper, ImportYeti scraper, supplier finder, industrial supplier scraper, B2B supplier leads, procurement research, import intelligence, manufacturer finder, sourcing automation.

# Actor input Schema

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

Industrial supplier, product, or category query.

## `sources` (type: `array`):

Supplier intelligence sources to use.

## `countries` (type: `array`):

Optional country filters.

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

Maximum number of supplier records to return.

## `includeContacts` (type: `boolean`):

Include contact signals in scoring.

## `includeShipmentData` (type: `boolean`):

Include shipment signals in scoring.

## `includeWebsiteEnrichment` (type: `boolean`):

Include website enrichment in later stages.

## `countryFilterMode` (type: `string`):

Strict drops records without a matching country when countries are provided. Lenient keeps records with unknown country and drops only explicit mismatches.

## `minLeadScore` (type: `integer`):

Minimum lead score filter.

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

Apify proxy configuration.

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

Maximum concurrent tasks.

## Actor input object example

```json
{
  "sources": [
    "thomasnet",
    "globalspec",
    "importyeti"
  ],
  "countries": [],
  "maxResults": 100,
  "includeContacts": true,
  "includeShipmentData": true,
  "includeWebsiteEnrichment": true,
  "countryFilterMode": "strict",
  "minLeadScore": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 5
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scraping_scrap/industrial-supplier-import-intelligence").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scraping_scrap/industrial-supplier-import-intelligence").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 '{}' |
apify call scraping_scrap/industrial-supplier-import-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraping_scrap/industrial-supplier-import-intelligence",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Industrial Supplier & Import Intelligence",
        "description": "Find industrial suppliers and import intelligence from ImportYeti, with best-effort ThomasNet and GlobalSpec checks. Export supplier profiles, shipment summaries, contacts, lead scores, and source health diagnostics.",
        "version": "0.1",
        "x-build-id": "OjWtRnoafN83g8YTZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraping_scrap~industrial-supplier-import-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraping_scrap-industrial-supplier-import-intelligence",
                "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/scraping_scrap~industrial-supplier-import-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-scraping_scrap-industrial-supplier-import-intelligence",
                "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/scraping_scrap~industrial-supplier-import-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-scraping_scrap-industrial-supplier-import-intelligence",
                "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",
                "required": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Query",
                        "pattern": "\\S",
                        "minLength": 1,
                        "type": "string",
                        "description": "Industrial supplier, product, or category query."
                    },
                    "sources": {
                        "title": "Sources",
                        "type": "array",
                        "description": "Supplier intelligence sources to use.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "thomasnet",
                                "globalspec",
                                "importyeti"
                            ],
                            "enumTitles": [
                                "Thomasnet",
                                "GlobalSpec",
                                "ImportYeti"
                            ]
                        },
                        "default": [
                            "thomasnet",
                            "globalspec",
                            "importyeti"
                        ]
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Optional country filters.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of supplier records to return.",
                        "default": 100
                    },
                    "includeContacts": {
                        "title": "Include contacts",
                        "type": "boolean",
                        "description": "Include contact signals in scoring.",
                        "default": true
                    },
                    "includeShipmentData": {
                        "title": "Include shipment data",
                        "type": "boolean",
                        "description": "Include shipment signals in scoring.",
                        "default": true
                    },
                    "includeWebsiteEnrichment": {
                        "title": "Include website enrichment",
                        "type": "boolean",
                        "description": "Include website enrichment in later stages.",
                        "default": true
                    },
                    "countryFilterMode": {
                        "title": "Country filter mode",
                        "enum": [
                            "strict",
                            "lenient"
                        ],
                        "type": "string",
                        "description": "Strict drops records without a matching country when countries are provided. Lenient keeps records with unknown country and drops only explicit mismatches.",
                        "default": "strict"
                    },
                    "minLeadScore": {
                        "title": "Minimum lead score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Minimum lead score filter.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy configuration.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum concurrent tasks.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
