# SHEIN Scraper (`datascrapers/shein-scraper`) Actor

Scrape SHEIN product listings by keyword, product ID, or URL. Returns prices, ratings, images, and optional reviews.

- **URL**: https://apify.com/datascrapers/shein-scraper.md
- **Developed by:** [Data Scrapers](https://apify.com/datascrapers) (community)
- **Security:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 products

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**SHEIN Scraper** creates a structured dataset of product listings collected from [SHEIN](https://www.shein.com) storefront search and product pages. Each dataset item is one product and can include identifiers, pricing, ratings, images, category labels, color variants, and optional nested `details` and `reviews` arrays on the same row. Query the source using keyword search, numeric goods IDs, or SHEIN URLs, control volume with `maxItems`, and retrieve records through the Apify Dataset API or export them as JSON, CSV, Excel, XML, or another supported format. Pricing starts from **$0.001 per product row**, with optional **$0.001** per details enrichment and **$0.001** per review when those options are enabled (verify current event prices in the Apify Console).

[![SHEIN Scraper — input to structured data](https://raw.githubusercontent.com/faizanalii/apify-actor-assets/main/shein-scraper/shein-scraper-value-demo.gif)](https://apify.com/datascrapers/shein-scraper)

### Dataset at a glance

| Property | Value |
| --- | --- |
| Source | [www.shein.com](https://www.shein.com) (regional hosts such as `de.shein.com`) |
| Record unit | One product listing |
| Input methods | `searchQueries`, `productIds`, `startUrls` |
| Main identifiers | `goodsId`, `url`, `goodsSn`, `spu` |
| Delivery | Apify default dataset and [Dataset API](https://docs.apify.com/api/v2/dataset-items-get) |
| Export formats | JSON, CSV, Excel, XML, RSS, HTML (via Apify export) |
| Update model | Fresh records per Actor run |
| Pricing | Pay per event: product row, optional details, optional reviews (see below) |

### Coverage and available records

**Supported**

- Keyword search with sort options (`recommend`, `newest`, `price_asc`, `price_desc`, `popular`)
- Direct fetch by SHEIN goods ID (`productIds`)
- Product or search URLs via `startUrls` (search URLs are treated as queries)
- Store context via `country` — currency and residential proxy country are set automatically (United Kingdom → GBP, Japan → JPY). Europe shares the EUR identity; the United States uses the US identity
- Listing-card fields: name, brand code, category, sale and retail price, discount, rating, review count, stock flags, images, color swatches
- Optional **details** object on the same row: description, attribute table, size and stock, gallery, store info, live price when returned
- Optional **reviews** array on the same row: text, rating, date, buyer size hints, images (up to `maxReviewsPerProduct`)

**Observed behavior**

- Residential proxies follow the selected store (GB → GB, JP → JP, with a nearby fallback when Apify has no exit for that ISO code)
- Products from multiple queries are enriched in parallel (up to six concurrent product jobs)
- Extra detail endpoints may be skipped when the storefront risk session is stale; the run continues with listing-card data only

**Not currently collected**

- Separate dataset rows per review (reviews stay nested under `reviews`)
- Guaranteed size or material fields on every listing (card-level `material` may contain UI metadata)
- Historical price snapshots across runs (each run is a new extract)
- Full marketplace coverage for a query in a single run (`maxItems` caps volume)

### Data dictionary

#### Product (top-level fields)

| Field | Type | Nullable | Description | Example |
| --- | --- | --- | --- | --- |
| `goodsId` | string | no | SHEIN goods ID | `"234115243"` |
| `goodsSn` | string | yes | Internal goods serial | `"sz25073006763685501"` |
| `spu` | string | yes | Style / SPU code | `"z250730067636"` |
| `productId` | string | yes | Product relation ID from the card | `"z250730067636"` |
| `name` | string | yes | Product title | `"Plus Size Knit Dress..."` |
| `url` | string | no | Public product URL for `country` | `https://de.shein.com/...-p-234115243.html` |
| `brand` | string | yes | Brand code on the card | `"1et3n"` |
| `category` | string | yes | Category name | `"Plus Size Dresses"` |
| `categoryId` | string | yes | Category ID | `"1889"` |
| `currency` | string | yes | ISO currency when present on the card | `"EUR"` |
| `salePrice` | number | yes | Numeric sale price | `25.49` |
| `salePriceDisplay` | string | yes | Formatted sale price | `"25.49€"` |
| `retailPrice` | number | yes | Numeric retail / reference price | `33.99` |
| `retailPriceDisplay` | string | yes | Formatted retail price | `"33.99€"` |
| `discountPrice` | number | yes | Discount amount when exposed | `0.0` |
| `discountPercent` | number | yes | Discount percentage | `0.0` |
| `rating` | number | yes | Average star rating from the card | `4.68` |
| `reviewCount` | integer | yes | Review count when numeric | `416` |
| `reviewCountDisplay` | string | yes | Display review count string | `"100+"` |
| `soldOut` | boolean | no | Sold-out flag from card | `false` |
| `stock` | string | yes | Stock indicator when present | `"1"` |
| `isClearance` | boolean | no | Clearance flag | `false` |
| `isOnSale` | boolean | no | On-sale flag | `false` |
| `isPlusSize` | boolean | no | Plus-size flag | `true` |
| `quickship` | boolean | no | Quickship flag | `true` |
| `mallCode` | string | yes | Mall code | `"1"` |
| `storeCode` | string | yes | Store code | `"4952344492"` |
| `imageUrl` | string | yes | Primary image URL | `https://img.ltwebstatic.com/...` |
| `detailImage` | string or string\[] | yes | Extra gallery URLs from search card | `[ "https://..." ]` |
| `videoUrl` | string | yes | Video reference when present | `"0"` |
| `colorImages` | string or array | yes | Color swatch image | URL or list |
| `colors` | object\[] | no | Related color variants `{ goodsId, image, color }` | may be empty entries |
| `labels` | array | no | Marketing labels from card | `[]` |
| `material` | object | yes | Raw card UI / material payload from search | nested object |
| `sourceQuery` | string | yes | Keyword, ID, or URL source for the row | `"dress"` |
| `scrapedAt` | string | no | UTC ISO-8601 scrape timestamp | `"2026-11-03T21:43:12.399768+00:00"` |
| `details` | object | yes | Present when `includeDetails` is true and detail APIs succeed | see below |
| `reviews` | object\[] | yes | Present when `includeReviews` is true | see below |

**Recommended deduplication key:** `goodsId` within a country-specific catalog. For cross-run dedup, use `goodsId` plus your run timestamp or dataset id.

#### `details` (when enabled and returned)

| Field | Type | Nullable | Description |
| --- | --- | --- | --- |
| `description` | string | yes | Product description text |
| `productDetails` | object\[] | no | Attribute rows `{ name, value }` |
| `materialDetails` | object | yes | Material block from detail API |
| `sizeAndStock` | array | no | Size and stock rows when exposed |
| `gallery` | array | yes | Detail gallery URLs |
| `video` | object | yes | Video metadata |
| `storeInfo` | object | yes | Store block |
| `salePrice` | number | yes | Live sale price from detail |
| `salePriceDisplay` | string | yes | Formatted live sale price |
| `currency` | string | yes | Currency on detail price |
| `stock` | string | yes | Stock from detail |
| `isOnSale` | boolean | yes | On-sale from detail |
| `realtime` | object | yes | Live stock, promotions, shipping hints when merged |

#### Review object (`reviews[]`)

| Field | Type | Nullable | Description |
| --- | --- | --- | --- |
| `commentId` | string | no | Review ID |
| `goodsId` | string | no | Parent goods ID |
| `rating` | number | yes | Star rating |
| `content` | string | yes | Review text |
| `translated` | string | yes | Translated text when provided |
| `language` | string | yes | Language flag |
| `date` | string | yes | Review date string from storefront |
| `userName` | string | yes | Display name |
| `userAvatar` | string | yes | Avatar URL |
| `userHeight` | string | yes | Buyer height hint |
| `userWeight` | string | yes | Buyer weight hint |
| `verifiedPurchase` | boolean | no | Verified purchase flag |
| `color` | string | yes | Purchased color |
| `size` | string | yes | Purchased size |
| `images` | array | no | Review image URLs |
| `videos` | array | no | Review video URLs |
| `likeCount` | integer | yes | Helpful votes |

### Example dataset record

Produced with `searchQueries: ["dress"]`, `country: "DE"`, `maxItems: 10`, `includeDetails` and `includeReviews` disabled (listing-card fields only):

```json
{
  "goodsId": "234115243",
  "goodsSn": "sz25073006763685501",
  "spu": "z250730067636",
  "productId": "z250730067636",
  "name": "Lounesse Plus Size Women High Neck Black Knit Long Sleeve Paired With Khaki Corduroy A-Line Skirt...",
  "url": "https://de.shein.com/Lounesse-Plus-Size-Women-High-Neck-Black-Knit-Long-Sleeve-Paired-With-Khaki-Corduroy-A-Line-Skirt-Plus-Size-Dress-For-Everyday-Wear-Date-Fashion-Winter-p-234115243.html",
  "brand": "1et3n",
  "category": "Plus Size Dresses",
  "categoryId": "1889",
  "currency": "",
  "salePrice": 25.49,
  "salePriceDisplay": "25.49€",
  "retailPrice": 33.99,
  "retailPriceDisplay": "33.99€",
  "discountPrice": 0.0,
  "discountPercent": 0.0,
  "rating": 4.68,
  "reviewCount": 416,
  "reviewCountDisplay": "100+",
  "soldOut": false,
  "stock": "1",
  "isClearance": false,
  "isOnSale": false,
  "isPlusSize": true,
  "quickship": true,
  "imageUrl": "http://img.ltwebstatic.com/v4/j/pi/2025/10/23/a5/17612028562f4138c1d56ab1af67ce7ea24141dd76_thumbnail_405x552.jpg",
  "sourceQuery": "dress",
  "scrapedAt": "2026-11-03T21:43:12.399768+00:00"
}
```

Long arrays such as `detailImage`, `colors`, and nested `material` are omitted here for readability.

### Query and input reference

| Input | Type | Required | Default | Accepted values | Description |
| --- | --- | ---: | --- | --- | --- |
| `searchQueries` | string\[] | no\* | prefill `dress` | Non-empty strings | Keyword search on SHEIN |
| `productIds` | string\[] | no\* | — | Goods IDs | Direct product lookup |
| `startUrls` | object\[] | no\* | search URL prefill | Product or search URLs | Request-list sources |
| `sort` | string | no | `recommend` | `recommend`, `newest`, `price_asc`, `price_desc`, `popular` | Search sort order |
| `country` | string | no | `US` | Store select (US, GB, FR, JP, AE, …) | Sets catalog, currency, and proxy country |
| `includeReviews` | boolean | no | `false` | true/false | Attach `reviews[]` |
| `maxReviewsPerProduct` | integer | no | `20` | ≥ 0 | Cap reviews per product |
| `includeDetails` | boolean | no | `false` | true/false | Attach `details` when APIs succeed |
| `maxItems` | integer | no | `0` | ≥ 0 | Max products; `0` = no cap |
| `proxyConfiguration` | object | no | residential | Apify proxy | Country is overwritten to match `country` |

\*At least one of `searchQueries`, `productIds`, or `startUrls` should be provided.

**Minimal request**

```json
{
  "searchQueries": ["dress"],
  "maxItems": 100,
  "country": "US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

**Advanced request (search + details + reviews)**

```json
{
  "searchQueries": ["winter jacket"],
  "maxItems": 50,
  "sort": "price_asc",
  "country": "US",
  "includeDetails": true,
  "includeReviews": true,
  "maxReviewsPerProduct": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Retrieve the data through the API

1. Start the Actor with JSON input (Apify Console, CLI, or HTTP API).
2. Wait for the run to finish, or use the synchronous dataset endpoint for small jobs.
3. Read items from the run’s default dataset (`GET /v2/datasets/{datasetId}/items`).
4. Paginate with `offset` and `limit`, or export the full dataset from the Console.

**Python (Apify client)**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")
run = client.actor("datascrapers/shein-scraper").call(
    run_input={
        "searchQueries": ["dress"],
        "maxItems": 25,
        "country": "US",
        "proxyConfiguration": {
            "useApifyProxy": True,
            "apifyProxyGroups": ["RESIDENTIAL"],
        },
    }
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["goodsId"], item.get("salePriceDisplay"), item.get("rating"))
```

**cURL (start run)**

```bash
curl -s -X POST "https://api.apify.com/v2/acts/datascrapers~shein-scraper/runs" \
  -H "Authorization: Bearer <YOUR_APIFY_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["dress"],"maxItems":10,"country":"US"}'
```

OpenAPI spec and generated clients are available on the Actor API tab in Apify Console.

### Data quality and record handling

- **Completeness:** Search cards populate most listing fields. `currency` may be empty on the card while `salePriceDisplay` still shows a formatted price. Optional `details` and `reviews` are omitted when disabled or when a single product fails enrichment.
- **Fail-soft:** One failed detail or review fetch does not stop the run; that product’s optional fields are skipped and processing continues.
- **Deduplication:** Within a run, the same `goodsId` should appear once per discovery path; cap volume with `maxItems`.
- **Cross-run dedup:** Not built in. Merge datasets on `goodsId` in your warehouse or use Apify webhooks to append only new ids.
- **Retries:** Transient network errors are retried on HTTP fetches; blocked detail endpoints are skipped after logging once per run.
- **Derived fields:** Public `url` is built from the listing slug, `goodsId`, and `country`. `scrapedAt` is set at parse time in UTC.

Run statistics (product, detail, and review charge counts) are stored in the key-value store under `run-stats`.

### Export and pipeline examples

| Destination | Recommended method | Typical use |
| --- | --- | --- |
| PostgreSQL / Supabase | Dataset API + scheduled Actor | Fashion catalog monitoring |
| Google Sheets | Apify integration or CSV export | Merchandising samples |
| S3 / cloud storage | Apify dataset export or webhook | Raw JSON archive |
| BI tools (Looker, Power BI) | CSV/Excel export | Price and rating dashboards |

### Pricing and cost examples

This Actor uses **pay-per-event** billing on the Apify platform. Placeholder Store prices (verify in Console before budgeting):

| Event | What triggers it | Placeholder unit price (Free tier) |
| --- | --- | ---: |
| Actor start | Each run | $0.00005 |
| `product` | Each product row pushed to the dataset | $0.001 |
| `product-details` | Each product where a non-empty `details` object is returned | $0.001 |
| `product-review` | Each review object inside `reviews` | $0.001 |

Higher Apify plans may receive tier discounts on result events. Residential proxy usage is billed separately through Apify proxy consumption.

**Illustrative totals (product event only, details/reviews off)**

| Products | Estimated product event cost |
| ---: | ---: |
| 1,000 | $1.00 |
| 10,000 | $10.00 |

**Illustrative totals (100 products, details on for 80 products, 20 reviews each)**

| Charge | Count | Placeholder cost |
| --- | ---: | ---: |
| Product rows | 100 | $0.10 |
| Details | 80 | $0.08 |
| Reviews | 2,000 | $2.00 |
| **Total (events only)** | | **~$2.18** |

Estimates exclude compute, proxy, and plan discounts. Edit event prices in the Apify Console monetization tab.

### Limitations and responsible data use

- Collects data exposed on the public SHEIN storefront for the selected country context; availability and fields change when SHEIN updates its apps or sites.
- You are responsible for complying with SHEIN terms, applicable commerce and privacy laws, and your own data retention policies.
- Reviews are user-generated content; do not treat them as verified facts without your own validation.
- Extra product details depend on storefront session state; runs may return listing cards only when detail endpoints are blocked.
- The Actor does not guarantee complete catalog coverage for a query—use filters, multiple queries, and repeated runs if you need broader samples.

### Dataset questions

#### What does one dataset item represent?

One SHEIN product listing from search, ID lookup, or URL discovery. Reviews and extended attributes are nested on that same item, not separate rows.

#### Which field should I use as a unique identifier?

Use `goodsId` as the primary key. Pair it with `country` if you compare the same style across regional storefronts.

#### Are fields nullable or conditional?

Yes. Card metrics may be partial. `details` and `reviews` appear only when enabled and successfully fetched. Individual review text or buyer fields may be empty.

#### Can I retrieve the records as CSV or JSON?

Yes. Export from the Apify Console or call the Dataset API with `format=csv` or `format=json`.

#### How do I paginate large datasets?

Use dataset API `offset` and `limit` parameters, or download split files from the Console export dialog.

#### Does the Actor return historical data?

Each run captures a current snapshot. Store dataset exports yourself if you need history.

#### Which countries return real store prices?

Select `country` only. Currency and the residential proxy exit follow that store (Japan → JPY + JP, United Kingdom → GBP + GB). The bundled identity is the **common/aws** store (Middle East, Asia, Americas, Oceania). Europe and the United States need their own data-center identity after a `switch-country` hop.

#### What counts as a billable result?

Each product row bills the `product` event. A returned `details` object bills `product-details` once for that product. Each object in `reviews` bills one `product-review` event.

### Related datasets from Data Scrapers

| Actor | Relationship |
| --- | --- |
| [AliExpress Scraper](https://apify.com/datascrapers/aliexpress-scraper) | Marketplace product rows with optional nested details and reviews |
| [H\&M Scraper](https://apify.com/datascrapers/h-and-m-scraper) | Apparel catalog listings with product-page enrichment |
| [Adidas Scraper](https://apify.com/datascrapers/adidas-scraper) | Brand retail product data for assortment comparison |

Browse the full [Data Scrapers Store profile](https://apify.com/datascrapers) for more commerce and catalog Actors.

### Data Scrapers support

Need an additional field, regional preset, or export workflow? Contact Data Scrapers at stardustspotlight@gmail.com. Include a sample SHEIN URL or search phrase, required fields, expected product volume, and whether you need nested reviews or details on every row.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search on SHEIN (for example "dress" or "winter jacket"). Primary input for agents — no URL required.

## `productIds` (type: `array`):

SHEIN goods IDs to fetch directly (for example "21628421").

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

Optional SHEIN product pages or search URLs, for example https://us.shein.com/floral-dress-p-21628421.html or a keyword search URL.

## `sort` (type: `string`):

How to order keyword search results.

## `country` (type: `string`):

SHEIN store. Currency and residential proxy country are set automatically (Japan → JPY + JP proxy, UAE → AED + AE proxy). The bundled identity covers the common/aws stores (Middle East, Asia, Americas, Oceania).

## `includeReviews` (type: `boolean`):

Attach customer reviews to each product record.

## `maxReviewsPerProduct` (type: `integer`):

Maximum reviews to attach when Include Reviews is enabled.

## `includeDetails` (type: `boolean`):

Attach size, material, and live price fields when the store returns them. Some extra-detail requests are skipped automatically.

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

Maximum number of products to scrape (0 = unlimited).

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

Residential proxies. The Actor always sets the proxy country to the selected store country.

## Actor input object example

```json
{
  "searchQueries": [
    "dress"
  ],
  "startUrls": [
    {
      "url": "https://us.shein.com/pdsearch/dress/"
    }
  ],
  "sort": "recommend",
  "country": "AE",
  "includeReviews": false,
  "maxReviewsPerProduct": 20,
  "includeDetails": false,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing scraped SHEIN products

## `kvsRecords` (type: `string`):

Key-value store record with record counts and timestamps

# 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 = {
    "searchQueries": [
        "dress"
    ],
    "startUrls": [
        {
            "url": "https://us.shein.com/pdsearch/dress/"
        }
    ],
    "country": "AE",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascrapers/shein-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 = {
    "searchQueries": ["dress"],
    "startUrls": [{ "url": "https://us.shein.com/pdsearch/dress/" }],
    "country": "AE",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("datascrapers/shein-scraper").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 '{
  "searchQueries": [
    "dress"
  ],
  "startUrls": [
    {
      "url": "https://us.shein.com/pdsearch/dress/"
    }
  ],
  "country": "AE",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call datascrapers/shein-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datascrapers/shein-scraper"
        }
    }
}
```

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/f30SaNxrukzrDSTAu/builds/c10EHcnLtJc9gVheO/openapi.json