# Uline Scraper (`maximedupre/uline-scraper`) Actor

Scrape Uline product data from category, listing, product URLs, or full catalog discovery. Export SKUs, names, prices, quantity price tiers, dimensions, weight, images, availability, breadcrumbs, specs, and source URLs.

- **URL**: https://apify.com/maximedupre/uline-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 scraped products

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

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

### 🛒 Uline product catalog scraper

Uline Scraper collects public product catalog data from [Uline](https://www.uline.com/). Add Uline category, listing, or product URLs, or choose full catalog discovery, then export product names, SKUs, prices, quantity price tiers, dimensions, weight, images, availability, breadcrumbs, specifications, product URLs, and source URLs.

Use this Uline product catalog scraper when you need repeatable product rows for procurement research, packaging catalog work, price checks, assortment analysis, or ecommerce reporting. Each accepted product is saved as soon as it is collected, so you can watch rows arrive during the run and stop once you have enough data.

For a useful first run, keep **Full catalog** selected with the default `maxItems` value. Review the dataset, then add Uline URLs and switch to **Provided URLs** when you need targeted Uline coverage.

### ✅ What this Actor does

- Scrapes public Uline category, listing, and product pages.
- Supports explicit full catalog discovery for broad Uline product collection.
- Accepts direct product URLs for targeted SKU checks.
- Extracts SKU, product name, description, category, subcategory, breadcrumb, product URL, source URL, and source position.
- Extracts visible prices, currency, quantity price tiers, dimensions, split length/width/height values, weight, availability, in-stock state, images, gallery URLs, and specifications when Uline shows them.
- Stops at your `maxItems` limit across the run.
- Works with Apify dataset exports, API clients, schedules, webhooks, and integrations.
- Runs without a Uline login, cookies, or a user-provided API key.

The Actor focuses on public Uline product catalog data. It does not collect private account prices, checkout data, shipping quotes, logged-in availability, price history, alerts, cross-run diffs, or downloaded image files.

### 📦 Data you can extract

Each dataset item is one Uline product. Fields can be empty when Uline does not show that value for a product.

- `sku` - Uline product identifier, preserved from the source.
- `name` and `description` - product text shown by Uline.
- `category`, `subcategory`, and `breadcrumb` - category context when visible.
- `unitPrice`, `currency`, and `priceTiers` - base price and bulk quantity breaks when shown.
- `dimensions`, `length`, `width`, `height`, and `weight` - size and weight details when available.
- `availability` and `inStock` - visible availability signals.
- `imageUrl` and `imageGallery` - primary and gallery image URLs.
- `specifications` - product attributes shown on the detail page.
- `productUrl`, `sourceUrl`, and `sourcePosition` - source evidence for audits and repeat runs.
- `rowWarnings` - completeness notes for emitted product rows.

### 🧭 Common use cases

- Build Uline catalog exports for packaging, warehouse, or procurement teams.
- Compare unit prices and quantity price breaks across similar Uline products.
- Monitor visible Uline availability for important SKUs.
- Pull dimensions, weight, and specifications into internal product systems.
- Collect product images and source URLs for catalog matching.
- Schedule recurring Apify runs and compare exported datasets outside the Actor.
- Feed clean Uline product rows into spreadsheets, BI tools, dashboards, or API workflows.

### 🚀 How to run

1. Add one or more Uline URLs to **Uline URLs**. You can paste category, listing, or product pages.
2. Choose **Full catalog** when you want the Actor to discover catalog pages, or **Provided URLs** for targeted scraping.
3. Set **Product limit**. The default is tuned for a useful first catalog run.
4. Start the Actor and open the dataset.

You do not need to provide a Uline account, cookies, an API key, or proxy settings.

### ⚙️ Input example

```json
{
	"startUrls": [
		{
			"url": "https://www.uline.com/BL_440/Lightweight-32-ECT-Boxes"
		}
	],
	"scrapeMode": "fullCatalog",
	"maxItems": 250
}
````

For a direct product check, paste a Uline product URL into `startUrls`. For a broader run, set `scrapeMode` to `fullCatalog` and keep `maxItems` set to a clear cap.

### 🧾 Output example

```json
{
	"sku": "S-4314",
	"name": "Lightweight 32 ECT Boxes",
	"description": "Lightweight corrugated boxes for shipping and storage.",
	"category": "Boxes",
	"subcategory": "Lightweight 32 ECT Boxes",
	"breadcrumb": [
		"Boxes",
		"Corrugated Boxes",
		"Lightweight 32 ECT Boxes"
	],
	"unitPrice": 0.44,
	"currency": "USD",
	"priceTiers": [
		{
			"quantity": 25,
			"price": 0.44
		}
	],
	"dimensions": "6 x 6 x 6\"",
	"length": "6",
	"width": "6",
	"height": "6",
	"weight": "0.2 lbs.",
	"availability": "In Stock",
	"inStock": true,
	"imageUrl": "https://images.uline.com/is/image/uline/S-4314",
	"imageGallery": [
		"https://images.uline.com/is/image/uline/S-4314"
	],
	"specifications": {
		"material": ["Corrugated"]
	},
	"productUrl": "https://www.uline.com/Product/Detail/S-4314",
	"sourceUrl": "https://www.uline.com/BL_440/Lightweight-32-ECT-Boxes",
	"sourcePosition": 1,
	"rowWarnings": []
}
```

Actual fields depend on what Uline shows on each product page. Missing optional values are left empty rather than guessed.

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each Uline product collected and saved. The Actor stops when it reaches your `maxItems` limit, so the easiest way to control cost is to keep a clear product cap on each run.

### ⚠️ Limits and caveats

- Full catalog discovery can cover many pages, so keep `maxItems` set to the number of products you actually need.
- Uline can show different optional details by category. Some products may not expose weight, gallery images, quantity tiers, or specifications.
- The Actor collects public product catalog data only. It does not log in to Uline or collect account-specific prices, saved carts, shipping estimates, or private customer data.
- Image fields are image URLs. The Actor does not download and store image files by default.

### ❓ FAQ

#### 🔎 Can I scrape one Uline product URL?

Yes. Paste the product URL into **Uline URLs**, keep **Provided URLs** selected, and set a small `maxItems` value.

#### 📂 Can I scrape a whole Uline category?

Yes. Paste the category or listing URL into **Uline URLs**. The Actor follows visible product links and stops at your product limit.

#### 🔌 Can I run this as a Uline API?

Yes. Like other Apify Actors, you can run it through the Apify API, export datasets, schedule runs, connect webhooks, or send results to integrations.

#### 🔐 Does it need a Uline account?

No. The Actor is built for public Uline catalog pages and does not ask for Uline credentials, cookies, or an API key.

### 📝 Changelog

- 1.0: Cleaner product rows with SKUs, prices, quantity tiers, dimensions, images, availability, specifications, source URLs, row warnings, dataset field metadata, and lower per-product pricing.
- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~uline-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [John Lewis Product Scraper ↗](https://apify.com/maximedupre/john-lewis-product-scraper) - Collect UK retail products, prices, availability, images, variants, and specifications.
- [Allegro Scraper ↗](https://apify.com/maximedupre/allegro-scraper) - Export Allegro product listings with prices, sellers, images, ratings, and delivery data.
- [Mercado Libre Search Scraper ↗](https://apify.com/maximedupre/mercado-libre-search-scraper) - Scrape Mercado Libre and Mercado Livre search result products by keyword or URL.
- [Google Shopping Ads Scraper ↗](https://apify.com/maximedupre/google-shopping-ads-scraper) - Monitor live Google Shopping ads with product, merchant, price, rank, and landing-page data.
- [G2 Products Scraper ↗](https://apify.com/maximedupre/g2-products-scraper) - Collect SaaS product profiles, ratings, review counts, categories, alternatives, and review samples.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Add Uline category, listing, or product URLs. Each URL is collected as part of the same run.

## `scrapeMode` (type: `string`):

Choose whether to collect from the URLs above or discover products from the Uline catalog.

## `maxItems` (type: `integer`):

Maximum product rows to save across the whole run. The default is tuned for a useful first catalog run.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.uline.com/BL_440/Lightweight-32-ECT-Boxes"
    }
  ],
  "scrapeMode": "fullCatalog",
  "maxItems": 250
}
```

# Actor output Schema

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

Open the dataset with Uline product rows.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.uline.com/BL_440/Lightweight-32-ECT-Boxes"
        }
    ],
    "maxItems": 250
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/uline-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 = {
    "startUrls": [{ "url": "https://www.uline.com/BL_440/Lightweight-32-ECT-Boxes" }],
    "maxItems": 250,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/uline-scraper").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 '{
  "startUrls": [
    {
      "url": "https://www.uline.com/BL_440/Lightweight-32-ECT-Boxes"
    }
  ],
  "maxItems": 250
}' |
apify call maximedupre/uline-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Uline Scraper",
        "description": "Scrape Uline product data from category, listing, product URLs, or full catalog discovery. Export SKUs, names, prices, quantity price tiers, dimensions, weight, images, availability, breadcrumbs, specs, and source URLs.",
        "version": "1.0",
        "x-build-id": "glWqsKRBEDSVeI2UT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~uline-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-uline-scraper",
                "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/maximedupre~uline-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-uline-scraper",
                "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/maximedupre~uline-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-uline-scraper",
                "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": {
                    "startUrls": {
                        "title": "Uline URLs",
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Add Uline category, listing, or product URLs. Each URL is collected as part of the same run.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "A Uline category, listing, or product URL.",
                                    "pattern": "^https?://(www\\.)?uline\\.com/"
                                }
                            }
                        }
                    },
                    "scrapeMode": {
                        "title": "Collection mode",
                        "enum": [
                            "providedUrls",
                            "fullCatalog"
                        ],
                        "type": "string",
                        "description": "Choose whether to collect from the URLs above or discover products from the Uline catalog.",
                        "default": "fullCatalog"
                    },
                    "maxItems": {
                        "title": "Product limit",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Maximum product rows to save across the whole run. The default is tuned for a useful first catalog run.",
                        "default": 250
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
