# Ecommerce Platform Profiler - Shopify, Woo, Magento (`mambalabs/ecommerce-platform-profiler`) Actor

Detects which ecommerce platform a company storefront runs on, plus its payment providers, subscription and marketplace apps, catalogue size, currencies and shipping destinations. Static homepage and sitemap reads only, no browser. One flat row per company, Clay ready.

- **URL**: https://apify.com/mambalabs/ecommerce-platform-profiler.md
- **Developed by:** [Mamba Labs](https://apify.com/mambalabs) (community)
- **Categories:** Lead generation, Automation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.45 / 1,000 company checkeds

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/actors/running/actors-in-store.md#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

### 🔎 What can Ecommerce Platform Profiler do?

Give it a company domain. It reads the storefront and returns which ecommerce platform it runs on, which payment providers it loads, whether it sells subscriptions, roughly how many products it lists, and which currencies it takes. One flat row per company.

Static reads only: the homepage, the sitemap, and optionally the public cart page. No browser, no checkout, nothing submitted.

| 📦 What you get | ⚙️ Features and integrations |
|---|---|
| 🛒 **Ecommerce platform** the storefront runs on<br>💳 **Payment providers**, subscription and marketplace apps<br>📦 **Catalogue size estimate**, currencies and shipping destinations<br>🧾 **22 flat fields**, `snake_case`, one row per company | ⚡ **Static homepage and sitemap reads only**, no browser<br>🎯 **Confidence and evidence per detection**, not a bare label<br>📊 **Coverage per row**, so a thin read is visible<br>⬇️ **Export** to JSON, CSV, Excel, HTML or XML |

Bought by ecommerce app and agency sellers, payments and subscription vendors, and anyone whose ICP is defined by the platform a storefront runs on.

> 🚫 **This is not a product or price scraper.** It profiles the storefront's platform and apps, once per company. It does not extract catalogues, product pages, prices or inventory.

### 💡 Why use Ecommerce Platform Profiler?

**It answers the question instead of handing you a list.** Generic technology detectors return every script on the page and leave you to work out which entry is the ecommerce platform. This returns `shopify`, with the evidence type and a confidence that follows that evidence.

**It refuses to guess.** A storefront that only reveals its platform after JavaScript runs reports `not_extractable`. It never returns the nearest plausible label, and a platform column full of confident wrong answers is worse than one with honest gaps.

**Catalogue size is marked as an estimate and its source is on the row.** A real read of the products endpoint and a count of sitemap URLs are not the same measurement and are never presented as if they were.

**It joins the rest of the fleet on `company_domain`**, including the Pinterest brand presence mapper, so a consumer brand list can carry social reach and commerce stack in one table.

#### 🧭 One read, several fingerprints

1. **Read the storefront homepage** with its response headers, which is where the strongest evidence lives: `powered-by: Shopify`, a `dwac_` cookie for Salesforce Commerce, an `x-magento-` header.
2. **Match the fingerprint tables** for platform, payment providers, subscription apps and marketplace marks. Confidence comes from the kind of evidence, not from the vendor.
3. **Estimate the catalogue**, from the Shopify products endpoint where the store is Shopify and from product URLs in the sitemap otherwise.
4. **Optionally read the public cart page**, because several buy now pay later providers load there and not on the homepage.

A storefront that answers 403 is retried once from a residential exit, and the row says whether that was needed.

### 📋 What data can Ecommerce Platform Profiler extract?

Every row carries **22 flat fields**. These are the ones a buyer
actually filters and sorts on.

| Field | Type | Meaning |
|---|---|---|
| `degraded` | boolean | True when this row could not be produced normally, for example the company site was unreachable and no discovery could run. A degraded row is never charged. |
| `degradation_reason` | string | null | Why the row is degraded, in plain words. Null on a normal row. |
| `company_domain` | string | null | The company domain this row is about, normalized. Null when only a handle or a name was supplied. This is the join key across the whole Mamba Labs fleet. |
| `company_name` | string | null | The company name as supplied or derived. Improves search accuracy and is what the identity gate matches against. |
| `ecommerce_platform` | string | null | The detected platform: shopify, woocommerce, magento, bigcommerce, salesforce\_commerce, squarespace\_commerce, wix\_stores, prestashop or commercetools. Null when nothing was detected, which on a site rendered entirely in JavaScript is a fact about the read rather than about the store. Check fetch\_status before reading a null here. |
| `platform_confidence` | string | null | high, medium or low, derived from the KIND of evidence rather than asserted per platform. A vendor response header or a platform cookie is high, a script host is medium, a substring in the page HTML is low. |
| `platform_evidence` | string | null | What actually matched, for example "header" or "script\_src". A detection you cannot inspect is a detection you have to take on trust. |
| `platforms_all` | string | null | Every platform whose marks appear, comma separated, when more than one does. Two platforms on one page usually means a migration in progress or a widget from another vendor, and collapsing that to one winner would throw away the evidence that tells them apart. |
| `payment_providers` | string | null | Payment and buy now pay later providers detected on the pages read, comma separated. Providers that load only inside a real checkout are invisible unless you switched checkCheckout on, so an absence here is weaker evidence than a presence. |
| `has_subscriptions` | boolean | null | True when a subscription app such as Recharge, Skio, Bold or Shopify Subscriptions was detected. FALSE means the pages were read and no subscription app was found, which is a real finding. NULL means the storefront could not be read at all. |
| `subscription_apps` | string | null | Which subscription apps were detected, comma separated. |
| `has_marketplace` | boolean | null | True when third party seller marks or a marketplace platform such as Mirakl was detected. FALSE means checked and absent. NULL means the storefront could not be read. |
| `product_count_estimate` | integer | null | An ESTIMATE of catalogue size, and the field name says so. From the Shopify products endpoint where available, which is a real catalogue read, and from product URLs in the sitemap otherwise, which counts variants, retired products and localized duplicates and cannot separate them. |
| `product_count_source` | string | null | products\_json means a real catalogue read. sitemap means a URL count, which is a much rougher number. Never compare a sitemap count against a products\_json count as if they measured the same thing. |
| `product_count_exact` | boolean | null | True only when the catalogue was read in full. FALSE means the count is a FLOOR: the products endpoint caps at 250 per page, so a store returning a full page has at least that many and probably more. |
| `currencies` | string | null | Currency codes offered, comma separated, read from a currency selector or from JSON-LD offers. A single currency is common and is not a failure. |
| `ships_to` | string | null | Country codes named in a shipping or country selector, comma separated. Coarse by nature: a selector lists where the store will take an order, not where it actually ships well. |
| `pages_read` | integer | null | How many pages were fetched for this company. Useful for reconciling a thin row against what it cost. |
| `escalated` | boolean | null | True when the first read was refused and a residential retry was needed. A row that needed escalation is a storefront defending itself, which is worth knowing before you plan a large batch against it. |
| `coverage` | number | null | How much of what this actor can return actually came back on this row, from 0 to 1. Computed over this actor value fields only, never over the identity or status columns. Null on a degraded row, where nothing was attempted. This is a reporting field: nothing is dropped for low coverage and no event fires on it. |
| `fetch_status` | string | ok, not\_found, not\_extractable, blocked, identity\_mismatch, auth\_failed or skipped. Read this before reading any value on the row. not\_found means we looked and there is nothing there; blocked and not\_extractable mean we could not look, and they must never be read as an absence. |
| `run_date` | string | ISO 8601 timestamp of this run. Social counts move, so a row without a date is a number with no shelf life. |

> ⚠️ **How to read these values.** `product_count_exact: false` means the number is a floor, not a total. The Shopify products endpoint caps at 250 per page, so a store returning a full page has at least that many.

### 🛠️ How to find out what platform an online store uses

1. Put a company domain in `company_domain`. That is the whole setup.
2. Leave `includeProductCount` on unless you are running a very large batch and only need the platform.
3. Turn `checkCheckout` on when you specifically care about buy now pay later providers, which often load only on the cart page.
4. For a list, pass an array of objects with the same fields.

#### 🧪 Using it in Clay

Add an **Enrichment > Apify** column, pick this actor, and map `company_domain` to your domain column.

The highest value pattern here is segmentation: filter your list on `ecommerce_platform` to find every Shopify merchant, then on `has_subscriptions` to find the ones already selling recurring, then on `product_count_estimate` to separate a 40 product brand from a 40,000 product retailer. Those three columns split a flat ecommerce list into genuinely different buyers.

### 💵 How much does it cost?

Pay per event. You are charged for output, never for input.

| Event | Fires when | Price |
|---|---|---|
| `company-checked` | Once per company for which the storefront read completed and a non degraded row was produced, whether or not anything was found. A not\_found row fires this event, because looking and finding nothing is a real answer and it is the work you asked for. A degraded row, where the lookup could not run at all, fires nothing. | $0.0035 |
| `platform-detected` | Once per company where an ecommerce platform was identified from the evidence. Does not fire when the storefront was read and no platform marks were found, and does not fire when the storefront could not be read at all, because in neither case was a platform detected. | $0.0030 |
| `product-count-estimated` | Once per company where a catalogue size was actually produced, from the products endpoint or from the sitemap. Does not fire when includeProductCount is off and does not fire when neither route yielded a number. | $0.0025 |

> 💳 **What you are billed for.** `platform-detected` fires only when a platform was actually identified. A storefront read with no platform marks, and a storefront that could not be read at all, both charge the check event and nothing more.
>
> `product-count-estimated` fires only when a number was produced.

**What the same coverage costs bought a la carte:** The Store carries general technology detectors that return long unranked lists of every script on a page, and the buyer does the work of deciding which entry is the ecommerce platform. This actor answers the one question directly, with the evidence type and a confidence that follows the evidence, and it adds catalogue size, payment providers and subscription detection that a generic detector does not attempt. It also refuses to guess: a JavaScript rendered storefront reports not\_extractable rather than the nearest label.

### ⌨️ Input

| Field | Type | Required | Meaning |
|---|---|---|---|
| `company_domain` | string | no | Bare company domain, for example allbirds.com. This is the storefront that gets read, and it is the join key against every other actor in the fleet including the Pinterest brand presence mapper. |
| `company_name` | string | no | Optional but strongly recommended. It is what the identity gate checks a discovered record against, so supplying it is the single cheapest way to reduce wrong matches. |
| `includeProductCount` | string | no | When "true" (default) the catalogue size is estimated, from the Shopify products endpoint where the store is Shopify and from the sitemap otherwise. It costs one or two extra requests. Sent as a string for Clay compatibility. |
| `includePaymentProviders` | string | no | When "true" (default) the payment provider scripts loaded on the storefront are detected. Providers that load only inside a real checkout are invisible from the homepage, which is why checkCheckout exists. Sent as a string for Clay compatibility. |
| `checkCheckout` | string | no | When "true" the public cart page is also read, because several payment and buy now pay later providers load there and not on the homepage. This never adds an item, never starts a checkout and never submits anything: it is a plain read of a public URL. Costs one extra request. Sent as a string for Clay compatibility. |
| `escalateOnBlock` | string | no | When "true" (default) a storefront that answers 403 or 429 is retried once from a residential exit, because a bot challenge on a first read is common and one retry clears a fair share of them. Set "false" to fail fast and cheap. Sent as a string for Clay compatibility. |
| `skipCache` | string | no | When "false" (default) a successful lookup is cached for seven days and reused, which costs you nothing on a repeated run. Set "true" to force a fresh fetch. Sent as a string for Clay compatibility. |

```json
{
  "company_domain": "allbirds.com",
  "company_name": "Allbirds",
  "includeProductCount": "true",
  "includePaymentProviders": "true"
}
```

### 📤 Output

Exports to **JSON, CSV, Excel, HTML or XML**. One flat, snake\_case row per
company. No nested objects, so it drops straight into Clay, a spreadsheet or a
warehouse table without a flattening step.

```json
{
  "degraded": false,
  "degradation_reason": null,
  "company_domain": "allbirds.com",
  "company_name": "Allbirds",
  "ecommerce_platform": "shopify",
  "platform_confidence": "high",
  "platform_evidence": "header",
  "platforms_all": "shopify",
  "payment_providers": "apple_pay",
  "has_subscriptions": false,
  "subscription_apps": null,
  "has_marketplace": false,
  "product_count_estimate": 250,
  "product_count_source": "products_json",
  "product_count_exact": false,
  "currencies": null,
  "ships_to": null,
  "pages_read": 2,
  "escalated": false,
  "coverage": 0.71,
  "fetch_status": "ok",
  "run_date": "2026-08-22T19:23:53.897Z"
}
```

#### false versus null, and why the difference matters

`false` means we looked and the answer is no. `null` means we could not look,
or the platform withheld it. They are never interchangeable in this output. If
you filter for companies with no presence on this platform, filter on `false`,
because `null` rows are unknown rather than absent and including them will
overstate your list.

### 💡 Tips

- **Filter on `platform_confidence: high` for anything that matters.** High means a vendor header or a platform cookie, which is proof rather than a hint.
- **`has_subscriptions: false` is a real finding** and a good prospecting signal for anyone selling subscription tooling. Null is the missing one.
- **Turn `checkCheckout` on for buy now pay later research.** Klarna and Afterpay frequently load only on the cart page.
- **Do not compare a sitemap product count against a products\_json count.** Check `product_count_source` first.
- **A `salesforce_commerce` or `commercetools` result means enterprise.** Those two are a size signal in themselves.

### ⚠️ Known limits

- **JavaScript rendered storefronts are invisible to a static read.** Measured on underarmour.com: a Next.js front end on Vercel with nothing about the commerce platform in the served HTML or headers. Those rows report `not_extractable`, which is a fact about the read and not about the store.
- **Payment providers that load only inside a real checkout cannot be seen.** This actor never starts a checkout. `checkCheckout` reads the public cart page and that is as far as it goes.
- **Product counts are estimates.** A sitemap carries variants, retired products and localized duplicates, and no static read separates them.
- **`ships_to` is coarse.** A country selector lists where a store will take an order, not where it ships well or quickly.
- **Some storefronts refuse us.** Measured on lush.com: an HTTP 403 Cloudflare challenge. The row reports `blocked`, which is never the same as having no platform.

### ❓ FAQ

**Why is the platform null on a store I know is Shopify?**
Read `fetch_status` first. `not_extractable` means the page was read and carried no platform marks, which happens on JavaScript rendered front ends. `blocked` means the storefront refused us.

**Does this add anything to a cart or start a checkout?**
No. Every request is a plain read of a public URL. `checkCheckout` reads the cart page; it does not use it.

**Why does the product count sometimes look too high?**
Because it came from the sitemap, which counts variants and retired products. `product_count_source` tells you which route produced the number.

**Can it detect two platforms at once?**
Yes, and `platforms_all` reports both. That usually means a migration in progress or a widget from another vendor, and it is information rather than an error.

**Does it need a proxy or an API key?**
Neither by default. A storefront that refuses the first read is retried once from a residential exit automatically.

### 🧩 Want other GTM data?

Mamba Labs builds a fleet of GTM enrichment actors that share one flat,
Clay-ready output convention, so their rows join on `company_domain` with no
cleaning step:

| | |
|---|---|
| 🕵️ [Agent Accessibility Auditor](https://apify.com/mambalabs/agent-accessibility-auditor) | 🤖 [AI Tooling Detector](https://apify.com/mambalabs/ai-tooling-detector) |
| 📡 [B2B Buying Signals Aggregator](https://apify.com/mambalabs/b2b-buying-signals-hiring-tech-stack-intent-for-clay) | 🚀 [Prospect Engine](https://apify.com/mambalabs/b2b-prospect-engine) |
| 📝 [Publishing Frequency Tracker](https://apify.com/mambalabs/blog-publishing-frequency) | ⏩ [Sequencer Lead Push](https://apify.com/mambalabs/clay-to-instantly-smartlead-push) |
| 🔄 [Company Change-Event Feed](https://apify.com/mambalabs/company-change-event-feed) | 🧭 [Company Discovery List Builder](https://apify.com/mambalabs/company-discovery-list-builder) |
| 🏢 [Company Firmographic Enricher](https://apify.com/mambalabs/company-firmographic-enricher) | 🪪 [Company Identity Resolver](https://apify.com/mambalabs/company-identity-resolver) |
| 🌐 [Company Social Presence Mapper](https://apify.com/mambalabs/company-social-presence-mapper) | 🏷️ [Contact Classifier](https://apify.com/mambalabs/contact-classifier) |
| 📬 [Domain Deliverability Checker](https://apify.com/mambalabs/domain-deliverability-checker) | 🔗 [Domain to LinkedIn URL Resolver](https://apify.com/mambalabs/domain-to-linkedin-url-resolver) |
| ✉️ [Work Email Waterfall Finder](https://apify.com/mambalabs/email-waterfall-orchestrator) | 🎪 [Event Presence Index](https://apify.com/mambalabs/event-presence-index) |
| 💰 [Funding and Press Signal Scanner](https://apify.com/mambalabs/funding-press-signal-scanner) | 🧑‍💼 [GTM Hiring Signal Scraper](https://apify.com/mambalabs/gtm-hiring-signal-scraper) |
| 📋 [Job Posting Monitor](https://apify.com/mambalabs/gtm-job-discovery) | 🧱 [Tech Stack Detector](https://apify.com/mambalabs/gtm-tech-stack-signal-scraper) |
| 🎯 [ICP Fit Scorer](https://apify.com/mambalabs/icp-account-lead-scoring-fit-scorer-0-100-for-clay) | 🔑 [Job Board Keyword Scanner](https://apify.com/mambalabs/job-board-keyword-signal-scanner) |
| ⚖️ [Legal Entity Resolver](https://apify.com/mambalabs/legal-entity-resolver) | 💼 [LinkedIn Company Page Mapper](https://apify.com/mambalabs/linkedin-company-presence-mapper) |
| 💬 [LinkedIn Post Tracker and Comment Capture](https://apify.com/mambalabs/linkedin-post-engager-capture) | 📸 [Instagram and Facebook Brand Mapper](https://apify.com/mambalabs/meta-brand-presence-mapper) |
| 📮 [Outbound Stack Detector](https://apify.com/mambalabs/outbound-infrastructure-fingerprint) | 📄 [Page Finder and Extractor](https://apify.com/mambalabs/page-finder-extractor) |
| 👤 [People Finder and Email Verifier](https://apify.com/mambalabs/people-finder) | 📌 [Pinterest Brand Presence Mapper](https://apify.com/mambalabs/pinterest-brand-presence-mapper) |
| 🏛️ [Government Contract Award Monitor](https://apify.com/mambalabs/public-award-monitor) | 📅 [Public Company Reporting Window Finder](https://apify.com/mambalabs/public-company-reporting-window-finder) |
| 👥 [Team Page People Extractor](https://apify.com/mambalabs/team-page-people-extractor) | 🎵 [TikTok Brand Presence Mapper](https://apify.com/mambalabs/tiktok-brand-presence-mapper) |
| 🏅 [Workplace Program Detector](https://apify.com/mambalabs/workplace-program-detector) | ▶️ [YouTube Channel Stats Extractor](https://apify.com/mambalabs/youtube-channel-transcript-extractor) |

> Every actor in the suite takes a domain or a company and returns one flat row,
> so they stack in the same Clay table without reshaping anything.

> 🛠️ **Need something custom built for you or your team?** Tell us what you are
> trying to find and we will build it. [Talk to Mamba Labs](https://mambabuilt.com/contact).

### 🆘 Support

Issues, field requests and bug reports: open an issue on the actor's Issues tab.
Mamba Labs reads every one.

> ℹ️ **Sourcing and legal.** Every field is read from the storefront's own public homepage and sitemap, with `robots.txt` honored. `product_count_estimate` is an estimate and `product_count_exact` tells you when it is not exact. You are responsible for how you use the output.

Built by [Mamba Labs](https://apify.com/mambalabs).

# Actor input Schema

## `company_domain` (type: `string`):

Bare company domain, for example allbirds.com. This is the storefront that gets read, and it is the join key against every other actor in the fleet including the Pinterest brand presence mapper.

## `company_name` (type: `string`):

Optional but strongly recommended. It is what the identity gate checks a discovered record against, so supplying it is the single cheapest way to reduce wrong matches.

## `includeProductCount` (type: `string`):

When "true" (default) the catalogue size is estimated, from the Shopify products endpoint where the store is Shopify and from the sitemap otherwise. It costs one or two extra requests. Sent as a string for Clay compatibility.

## `includePaymentProviders` (type: `string`):

When "true" (default) the payment provider scripts loaded on the storefront are detected. Providers that load only inside a real checkout are invisible from the homepage, which is why checkCheckout exists. Sent as a string for Clay compatibility.

## `checkCheckout` (type: `string`):

When "true" the public cart page is also read, because several payment and buy now pay later providers load there and not on the homepage. This never adds an item, never starts a checkout and never submits anything: it is a plain read of a public URL. Costs one extra request. Sent as a string for Clay compatibility.

## `escalateOnBlock` (type: `string`):

When "true" (default) a storefront that answers 403 or 429 is retried once from a residential exit, because a bot challenge on a first read is common and one retry clears a fair share of them. Set "false" to fail fast and cheap. Sent as a string for Clay compatibility.

## `skipCache` (type: `string`):

When "false" (default) a successful lookup is cached for seven days and reused, which costs you nothing on a repeated run. Set "true" to force a fresh fetch. Sent as a string for Clay compatibility.

## `source_tag` (type: `string`):

Internal attribution tag set by Mamba Labs on published task examples. Not required, and nothing depends on it. Leave it empty.

## Actor input object example

```json
{
  "company_domain": "allbirds.com",
  "company_name": "Allbirds",
  "includeProductCount": "true",
  "includePaymentProviders": "true",
  "checkCheckout": "false",
  "escalateOnBlock": "true",
  "skipCache": "false"
}
```

# Actor output Schema

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

Dataset of one flat row per company, with per platform status so a blocked fetch never reads as a zero.

# 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 = {
    "company_domain": "allbirds.com",
    "company_name": "Allbirds"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mambalabs/ecommerce-platform-profiler").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 = {
    "company_domain": "allbirds.com",
    "company_name": "Allbirds",
}

# Run the Actor and wait for it to finish
run = client.actor("mambalabs/ecommerce-platform-profiler").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "company_domain": "allbirds.com",
  "company_name": "Allbirds"
}' |
apify call mambalabs/ecommerce-platform-profiler --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mambalabs/ecommerce-platform-profiler"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5G2NeYjBbQTjaTn9L/builds/BSzaXxl96TRTZpmtP/openapi.json