# Supplier Intelligence Monitor (`geneius/supplier-intelligence-monitor`) Actor

Analyze ImportYeti, Thomasnet, Alibaba, or supplier-directory records into sourcing opportunities, risk scores, capabilities, and watchlist actions.

- **URL**: https://apify.com/geneius/supplier-intelligence-monitor.md
- **Developed by:** [Gene](https://apify.com/geneius) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.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

### Supplier Intelligence Monitor

Analyze ImportYeti, Thomasnet, Alibaba, and supplier-directory records into **sourcing opportunities, risk scores, capability tags, and watchlist actions**.

This Actor is for procurement teams, importers, Amazon sellers, industrial sales teams, and sourcing agencies that already collect supplier records but need a repeatable way to prioritize them.

### What You Learn

- Which suppliers look like stronger sourcing opportunities
- Which suppliers need risk review before outreach
- Which capabilities appear in supplier profiles
- Which suppliers mention export activity, certifications, manufacturing, or industrial specialization
- What sourcing action to take next

### Use Cases

- Supplier shortlisting
- Competitor sourcing research
- ImportYeti-style shipment dataset enrichment
- Thomasnet or Alibaba supplier list scoring
- Procurement watchlists and sourcing-agent workflows

### Input

Provide supplier records inline or pass an Apify `datasetId` from another supplier scraper.

```json
{
  "defaultCategory": "electronics",
  "suppliers": [
    {
      "supplierName": "Pacific Components",
      "description": "ISO certified electronics manufacturer with export shipments and custom assembly capacity.",
      "shipmentCount": 120,
      "country": "Taiwan"
    }
  ],
  "maxSuppliers": 100
}
````

### Output

Each dataset item is one analyzed supplier profile:

```json
{
  "status": "succeeded",
  "recordIndex": 1,
  "billingEventName": "supplier-profile-analyzed",
  "supplierName": "Pacific Components",
  "category": "electronics",
  "country": "Taiwan",
  "shipmentCount": 120,
  "capabilities": ["manufacturing", "export", "certification", "industrial"],
  "riskScore": 20,
  "opportunityScore": 100,
  "recommendedAction": "Prioritize Pacific Components for sourcing research; capabilities suggest a strong fit: manufacturing, export, certification."
}
```

The run also writes a `SUMMARY` key-value-store record with supplier counts and capability counts.

### FAQ

#### Does this scrape supplier directories?

No. It analyzes supplier records you provide inline or through an Apify dataset from another Actor. It is a sourcing intelligence layer, not an ImportYeti, Thomasnet, Alibaba, or IndiaMart scraper.

#### What input do I need for the first run?

Use the Store example with `defaultCategory` and one or more supplier records. Supplier name and description are the most useful fields; country, shipment count, rating, website, and certifications improve scoring.

#### What do I get back?

One dataset item per analyzed supplier, including capabilities, risk score, opportunity score, and recommended sourcing action. The run also writes a `SUMMARY` record.

#### Who is this for?

Procurement teams, importers, Amazon sellers, industrial sales teams, and sourcing agencies that need recurring supplier shortlists and risk triage.

#### When is it commercially chargeable?

The configured paid event is `supplier-profile-analyzed` at `$0.04`, scheduled for 2026-05-26T21:05:10Z. Run a small paid smoke after activation before promoting high-volume use.

### Pricing

Default monetization model: pay per event.

Recommended chargeable event:

- Event name: `supplier-profile-analyzed`
- Event meaning: one successfully analyzed supplier profile
- Store price: `$0.04` per analyzed supplier profile
- Pricing activation: scheduled for `2026-05-26T21:05:10Z`

Successful rows are pushed only after the charge path allows the event. Run a paid smoke after the scheduled activation time before promoting the listing.

### Limitations

- This MVP analyzes supplier records; it does not scrape ImportYeti, Thomasnet, Alibaba, or IndiaMart directly.
- Source schemas vary. The Actor recognizes common fields such as `supplierName`, `companyName`, `description`, `country`, `shipmentCount`, `rating`, and `website`.
- Demand is narrower than review and jobs actors, so use it for focused sourcing workflows.

### Automation And Agent Use

- Run a supplier scraper first, then pass its dataset ID to this Actor.
- Schedule watchlist analysis for target categories.
- Send high-opportunity suppliers to a sourcing spreadsheet or CRM.
- Send high-risk suppliers to a verification queue.

### Local Development

```bash
python3 -m pip install -r requirements.txt
ACTOR_TEST_PAY_PER_EVENT=true apify run --purge --input-file examples/smoke-input.json
```

# Actor input Schema

## `defaultCategory` (type: `string`):

Fallback supplier category when a record does not include one.

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

Optional supplier records from ImportYeti, Thomasnet, Alibaba, or other supplier directories.

## `datasetId` (type: `string`):

Optional Apify dataset ID containing supplier records from another Actor.

## `maxSuppliers` (type: `integer`):

Safety cap for analyzed suppliers in one run.

## `datasetItemLimit` (type: `integer`):

Maximum number of records to load from the source dataset.

## `failOnInvalidRecord` (type: `boolean`):

When enabled, the Actor fails on the first invalid supplier record instead of returning partial error records.

## Actor input object example

```json
{
  "defaultCategory": "electronics",
  "suppliers": [
    {
      "supplierName": "Pacific Components",
      "description": "ISO certified electronics manufacturer with export shipments and custom assembly capacity.",
      "shipmentCount": 120,
      "country": "Taiwan"
    }
  ],
  "maxSuppliers": 100,
  "datasetItemLimit": 100,
  "failOnInvalidRecord": false
}
```

# Actor output Schema

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

Dataset items with one row per supplier profile, including capabilities, risk, opportunity score, and recommended action.

## `summary` (type: `string`):

Run-level summary with analyzed supplier count, failures, charge event name, and capability counts.

# 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 = {
    "defaultCategory": "electronics",
    "suppliers": [
        {
            "supplierName": "Pacific Components",
            "description": "ISO certified electronics manufacturer with export shipments and custom assembly capacity.",
            "shipmentCount": 120,
            "country": "Taiwan"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("geneius/supplier-intelligence-monitor").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 = {
    "defaultCategory": "electronics",
    "suppliers": [{
            "supplierName": "Pacific Components",
            "description": "ISO certified electronics manufacturer with export shipments and custom assembly capacity.",
            "shipmentCount": 120,
            "country": "Taiwan",
        }],
}

# Run the Actor and wait for it to finish
run = client.actor("geneius/supplier-intelligence-monitor").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 '{
  "defaultCategory": "electronics",
  "suppliers": [
    {
      "supplierName": "Pacific Components",
      "description": "ISO certified electronics manufacturer with export shipments and custom assembly capacity.",
      "shipmentCount": 120,
      "country": "Taiwan"
    }
  ]
}' |
apify call geneius/supplier-intelligence-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Supplier Intelligence Monitor",
        "description": "Analyze ImportYeti, Thomasnet, Alibaba, or supplier-directory records into sourcing opportunities, risk scores, capabilities, and watchlist actions.",
        "version": "0.1",
        "x-build-id": "eoxBZ2Eo8D4EIWYlD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/geneius~supplier-intelligence-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-geneius-supplier-intelligence-monitor",
                "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/geneius~supplier-intelligence-monitor/runs": {
            "post": {
                "operationId": "runs-sync-geneius-supplier-intelligence-monitor",
                "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/geneius~supplier-intelligence-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-geneius-supplier-intelligence-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "defaultCategory": {
                        "title": "Default category",
                        "type": "string",
                        "description": "Fallback supplier category when a record does not include one.",
                        "default": "supplier"
                    },
                    "suppliers": {
                        "title": "Inline supplier records",
                        "minItems": 1,
                        "type": "array",
                        "description": "Optional supplier records from ImportYeti, Thomasnet, Alibaba, or other supplier directories."
                    },
                    "datasetId": {
                        "title": "Source dataset ID",
                        "minLength": 1,
                        "type": "string",
                        "description": "Optional Apify dataset ID containing supplier records from another Actor."
                    },
                    "maxSuppliers": {
                        "title": "Maximum suppliers",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Safety cap for analyzed suppliers in one run.",
                        "default": 100
                    },
                    "datasetItemLimit": {
                        "title": "Dataset item limit",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of records to load from the source dataset.",
                        "default": 100
                    },
                    "failOnInvalidRecord": {
                        "title": "Fail on invalid record",
                        "type": "boolean",
                        "description": "When enabled, the Actor fails on the first invalid supplier record instead of returning partial error records.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
