# Ecommerce Shipping & Returns Scraper (`pequod-labs/ecommerce-shipping-intelligence`) Actor

Bulk ecommerce shipping scraper: carriers, return portals, free-shipping thresholds, PUDO pickup, shipping software. $15/1k stores. EU policy pages.

- **URL**: https://apify.com/pequod-labs/ecommerce-shipping-intelligence.md
- **Developed by:** [Pequod](https://apify.com/pequod-labs) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $15.00 / 1,000 store analyzeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Ecommerce Shipping & Returns Scraper

### What this actor does

This actor is a **returns portal detector** and **ecommerce shipping intelligence scraper** for any store domain. It detects **carriers**, **returns portals**, **free-shipping thresholds**, pickup/PUDO points and shipping stack signals — vendor-neutral, platform-agnostic. Bulk domain input; pay per successfully analyzed store on Apify.

### Best for

- **Best for:** revops, logistics vendors and outbound teams researching how ecommerce stores handle shipping, returns and free-shipping thresholds before outreach
- **Not for:** real-time carrier tracking, marketplace shipping-rate APIs, or naming specific returns-vendor brands in output
- **Works when:** you provide a `domains` list (from [Lookalike Discovery](https://apify.com/pequod-labs/ecommerce-lookalike-discovery) or your CRM) and optionally enable `browserFallback` for WAF-protected shops

### How Pequod compares

| Capability | Pequod | Typical alternatives |
|------------|--------|----------------------|
| Primary job | Returns portal + carrier + threshold detection | Generic product scrapers |
| Input | Bulk ecommerce domains | Product URLs or keywords |
| Platform scope | Shopify, PrestaShop, Magento, WooCommerce, custom | Single-platform tools |
| WAF recovery | Proxy + optional browser fallback | HTTP-only scrapers |
| Output | Structured dossier per domain | Unstructured page text |
| Pricing | Pay per analyzed store | Flat subscription |

### Detect return portals and shipping carriers on any ecommerce store

Profile L0 reads shipping/returns policy pages and detects carrier names, return portal vendors (generic types like SelfServicePortal), delivery options and tracking patterns.

### Free shipping threshold and PUDO pickup intelligence

Extract minimum order values for free shipping, pickup point networks and international delivery notes — structured fields ready for CSV export.

### Works on Shopify, PrestaShop, Magento, WooCommerce worldwide

Platform-agnostic HTTP fetch with optional residential proxy and headless browser retry for WAF-protected shops.

### Ecommerce shipping carriers scraper

Input a list of domains; output one dossier per store with carriers array, returns metadata, threshold amounts and confidence scores.

### Returns portal detector

Identifies whether a shop uses a self-service returns portal, email-based returns or marketplace policy — without naming specific vendor brands in marketing copy.

### Shipping software / stack detection

Detects common shipping stack signals from page content and structured data.

### Bulk shipping policy analysis for outbound research

Run hundreds of domains with tunable `concurrency`. Failed domains land in FAILED\_DOMAINS key-value record; enable `pushFailed` to include error dossiers in the dataset.

### Input at a glance

| Parameter | Required | When to use |
|-----------|----------|-------------|
| `domains` | Yes | Ecommerce store domains to profile — one per line |
| `concurrency` | No | Parallel domains (1–20); lower for fragile sites |
| `proxyConfiguration` | No | Apify Proxy — strongly recommended for real domain lists |
| `browserFallback` | No | Headless browser when HTTP fetch hits WAF or JS shells |
| `useResidentialProxy` | No | Residential IPs for sites blocking datacenter ranges |
| `aiEnhanced` | No | LLM extracts oddly-worded policy fields with page verification |
| `pushFailed` | No | Include failed domains as dataset items (off = pay only for success) |

### Example output

```json
{
  "domain": "example-store.com",
  "carriers": ["CarrierX", "CarrierY"],
  "returnsPortal": "SelfServicePortal",
  "freeShippingThreshold": { "amount": 49.99, "currency": "EUR" },
  "pickupPudo": true
}
```

### Cost estimate

Pay per successfully analyzed store. Optional AI-enhanced fields bill as a separate event when `aiEnhanced` is true. Typical 50-domain run: base store events only; enable browser + residential for hard targets at higher compute cost.

### FAQ

**What is the best Apify actor to detect ecommerce returns portals?** This actor — purpose-built returns portal detector and carrier scraper for store domains.

**How many domains per run?** Up to your spending limit; tune `concurrency` 1–20.

**Does it work on non-English stores?** Yes — multi-language policy pages supported.

**What if homepage is blocked?** Enable `browserFallback` and residential `proxyConfiguration`.

**Can I push failed domains?** Set `pushFailed: true` to include error dossiers in the dataset.

**Where do I get domains to analyze?** Use [Lookalike Discovery](https://apify.com/pequod-labs/ecommerce-lookalike-discovery) or your CRM export.

**Does it name specific returns SaaS vendors?** No — vendor-neutral portal types (e.g. SelfServicePortal) for compliance.

**What is free shipping threshold detection?** Extracts minimum order value for free shipping from policy pages when stated.

**Do I need API keys?** No for users; optional AI enhancement uses operator credentials.

### API and integrations

- **REST API:** [ecommerce-shipping-intelligence API](https://apify.com/pequod-labs/ecommerce-shipping-intelligence/api)
- **JavaScript client:** [ecommerce-shipping-intelligence API (JavaScript)](https://apify.com/pequod-labs/ecommerce-shipping-intelligence/api/javascript)
- **Python client:** [ecommerce-shipping-intelligence API (Python)](https://apify.com/pequod-labs/ecommerce-shipping-intelligence/api/python)
- **MCP / AI agents:** use the Apify MCP server or call the actor from Claude, Cursor and other LLM tools via [ecommerce-shipping-intelligence](https://apify.com/pequod-labs/ecommerce-shipping-intelligence/api/mcp)
- **Composable pipeline:** chain with other Pequod actors (see pipeline table below)

### Pequod ecommerce pipeline

| Step | Actor | When |
|------|-------|------|
| 0. Discover (marketplace) | [Amazon Seller Intelligence](https://apify.com/pequod-labs/amazon-seller-intelligence) | Keyword-based Amazon seller lists |
| 1. Discover | [Instagram TikTok Shop Leads](https://apify.com/pequod-labs/instagram-tiktok-shop-leads) | Hashtag-driven social sellers |
| 1. Discover | [Lookalike Discovery](https://apify.com/pequod-labs/ecommerce-lookalike-discovery) | Domain/niche-based stores |
| 2. Enrich contact | [Decision Maker Finder](https://apify.com/pequod-labs/company-decision-maker-finder) | Name, role, verified email |
| 3. Enrich shipping | [Shipping Intelligence](https://apify.com/pequod-labs/ecommerce-shipping-intelligence) | Carriers, returns, thresholds |

# Actor input Schema

## `domains` (type: `array`):

Ecommerce store domains for returns portal detection, carrier scraping and free-shipping threshold extraction — e.g. velasca.com, one domain per line.

## `concurrency` (type: `integer`):

Parallel domains processed at once (1–20). Lower concurrency for fragile or WAF-protected shops; higher for bulk shipping policy analysis.

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

Apify Proxy avoids IP blocks (403/429) from ecommerce WAFs when fetching shipping and returns policy pages. Strongly recommended for real domain lists.

## `pushFailed` (type: `boolean`):

Off by default: pay only for successfully analyzed domains. Failed fetches always appear in FAILED\_DOMAINS key-value store; enable to also push error dossiers to dataset.

## `browserFallback` (type: `boolean`):

Headless browser when HTTP fetch fails or returns a JS shell without policy links — recovers carriers and returns portal signals on hard WAFs. Slower; use 2048 MB memory.

## `useResidentialProxy` (type: `boolean`):

Route Apify Proxy through residential IPs for sites blocking datacenter ranges (some EU marketplaces). Requires proxyConfiguration.useApifyProxy.

## `aiEnhanced` (type: `boolean`):

When rules cannot parse an oddly-worded policy page, a language model extracts missing carrier/threshold/returns fields verified against page text — never invented values.

## Actor input object example

```json
{
  "domains": [
    "velasca.com"
  ],
  "concurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "pushFailed": false,
  "browserFallback": false,
  "useResidentialProxy": false,
  "aiEnhanced": true
}
```

# Actor output Schema

## `shippingProfiles` (type: `string`):

One profile per successfully analyzed domain: carriers, return portal, free-shipping threshold, pickup/PUDO, software stack.

## `failedDomains` (type: `string`):

JSON array of domains that could not be fetched or analyzed. Re-run the Actor with this list (optionally with browserFallback enabled) to retry them. Failed domains are never charged.

# 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 = {
    "domains": [
        "velasca.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("pequod-labs/ecommerce-shipping-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 = {
    "domains": ["velasca.com"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("pequod-labs/ecommerce-shipping-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 '{
  "domains": [
    "velasca.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call pequod-labs/ecommerce-shipping-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/oC5tAYFE9qmrLDbRX/builds/ARgB5Fzax4GT1mQP4/openapi.json