# Vogue Scraper - Fashion, Runway, Designers & Shopping (`abotapi/vogue-com-scraper`) Actor

Scrape Vogue fashion, beauty and culture articles with full text, runway shows, look galleries, designer archives and shopping picks with product details. Browse by channel, season or tag. Supports resume, incremental monitoring and MCP export.

- **URL**: https://apify.com/abotapi/vogue-com-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 records

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?

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

## Vogue Scraper: Articles, Runway Shows, Designers & Shopping

Vogue Scraper turns Vogue into a clean fashion data API. Collect fashion news, beauty and culture stories with full text and bylines, runway shows with complete look galleries, designer archive pages with biography and collection history, and the shopping picks inside editor's guides with store offer links. Walk the site's section feeds, collect a whole fashion week season, read designer pages, or paste any page link, then export to JSON, CSV or Excel, or pull the results straight into your app through the API.

### Why This Scraper?

- **Four ways in.** Walk the section feeds (Fashion, Beauty, Culture, Living, Weddings, Shopping, Magazine, Video), collect every show in a runway season, read designer archives, or paste any page link - articles, slideshows, shows, tags, contributor pages.
- **Four record types, fully expanded.** Articles, shopping picks, runway shows and designers each carry their complete field set: full story text, look-by-look galleries with credits, store offer links.
- **Runway depth.** A show record carries every look in the collection - number, caption, image URL and alt text - plus the review author and standfirst.
- **Shopping picks with store links.** Enriched stories emit their embedded products as their own rows: brand, product name, price when shown, and the store's own offer page.
- **Designer archives.** Each designer record carries the label biography and every collection page on the site, newest first.
- **Built for schedules.** Incremental mode returns only new and changed stories on recurring runs, unchanged stories are not re-read, and a refused run fails loudly instead of returning an empty dataset.

### Use Cases

- **Trend and market research:** collect story text, keywords and runway galleries season over season to track trends, designers and coverage.
- **Retail and merchandising intelligence:** mine the shopping picks inside editor's guides for brands, products and store links.
- **AI and LLM pipelines:** feed clean full-text fashion articles and structured show data into retrieval, summarization or agent workflows.
- **Media monitoring:** follow a section feed or a tag for new stories on a schedule and receive only what changed.
- **Fashion week coverage:** pull a whole season's shows with reviewers and look counts in one run.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `recordType` | `"article"` (also `"product"`, `"show"`, `"designer"`) |
| `recordId` | `"article:sample-story"` |
| `title` | `"Sample Story Headline"` |
| `dek` | `"The standfirst line"` |
| `url` | Article, show or designer page link; the store offer link on product rows |
| `section` / `subsections` / `breadcrumbs` | `"Fashion"` / `["fashion", "trends"]` / `["Fashion", "Story"]` |
| `contentType` | `"article"` (also `"slideshow"`, `"video"`, `"gallery"`) |
| `authors` / `authorUrls` / `editorNames` | `["Sample Byline"]` / contributor page links / `["Sample Editor"]` |
| `pubDate` / `dateModified` / `publishDate` | `"2026-10-24T09:30:00-04:00"` |
| `imageUrl` / `imageUrls` | lead image and the full photo list |
| `keywords` / `bodyText` / `wordCount` | `["fashion week", "trend"]` / full story text (detail pages) / its counts |
| `contentId` / `templateType` / `revisions` | editorial metadata for the story |
| `isCommerceContent` / `hasBuyButtons` / `affiliateLinksCount` | commerce flags on the story |
| `productsFound` | number of shopping picks in the story |
| `brand` / `title` (products) | `"Sample Brand"` / `"Sample Item"` |
| `merchant` / `retailer` / `offerUrl` / `clickoutUrl` / `cardFamily` | store host and display name / the store's product page / the affiliate redirect / `"unified"` or `"summary"` |
| `price` / `currency` / `wasPrice` / `discountPercent` | `400` / `"USD"` / `500` / `20` when on sale |
| `seller` / `sellerCount` / `offers` | `"NET-A-PORTER"` / every seller with price, was-price, store link and stock |
| `designer` / `season` / `seasonName` | `"Sample Label"` / `"spring-2027-ready-to-wear"` / `"Spring 2027 Ready-to-Wear"` |
| `lookCount` / `looks` / `detailShots` | `64` / one entry per look / the close-up gallery |
| `eventDate` / `designersDek` / `contributors` | show date-time / creative-director line / review bylines |
| `reviewText` / `reviewer` / `relatedShows` | the full review / `"Sample Reviewer"` / sibling shows |
| `bio` / `collectionsCount` / `recentShows` | designer biography / archive size / every collection (title, link, image) |
| `relatedArticles` | coverage from the designer archive |
| `changeType` / `changedFields` | `"NEW"` / incremental-mode bookkeeping |

### How to Use

1. Pick a **mode**: `articles` (section feeds), `search` (the site's own search), `shopping` (product grids by category), `runway` (fashion shows by season), `designers` (designer archives) or `links` (paste page links).
2. Fill in the fields for that mode, and keep **Read detail pages** on for full text, galleries and shopping picks.
3. Set **Max items** to control run size and cost, then click **Start**.
4. Download the dataset as JSON, CSV or Excel, or read it through the API.

**Walk the section feeds:**

```json
{
  "mode": "articles",
  "channels": ["fashion", "beauty"],
  "fetchDetails": true,
  "maxItems": 20
}
```

**Search products and stories** (the site's own search; shopping stories ship their picks as product rows):

```json
{
  "mode": "search",
  "searchQueries": ["handbag", "winter coat"],
  "searchSort": "newest",
  "fetchDetails": true,
  "maxItems": 20
}
```

**Read the shopping grids** (structured products with price, was-price, seller and stock):

```json
{
  "mode": "shopping",
  "shoppingCategories": ["new-arrivals", "bags", "shoes"],
  "productBrands": [],
  "productSort": "site-order",
  "maxItems": 60
}
```

**Paste any page links:**

```json
{
  "mode": "links",
  "startUrls": [
    "https://www.vogue.com/article/sample-story",
    "https://www.vogue.com/fashion-shows/spring-2027-ready-to-wear/sample-label"
  ]
}
```

Supported link shapes (each is routed to its own reader):

| Link | Example |
|---|---|
| Article | `/article/story-name` |
| Slideshow | `/slideshow/gallery-name` |
| Show | `/fashion-shows/spring-2027-ready-to-wear/label` |
| Look slideshow | `/fashion-shows/<season>/<label>/slideshow/collection#1` (resolves to the show) |
| Season index | `/fashion-shows/spring-2027-ready-to-wear` |
| Designer | `/fashion-shows/designer/label` |
| Designer index | `/fashion-shows/designers` (every designer, A-Z) |
| Tag | `/tag/name` or `/tag/misc/name` |
| Contributor | `/contributor/name` |
| Section feed | `/fashion`, `/beauty`, `/culture`, `/living`, `/weddings`, `/shopping`, `/magazine`, `/video` |

A link the actor cannot use is reported in the run log - it is never silently dropped and never misrouted. A page you paste in Links mode is always actually read; **Read detail pages** only controls feed-mode enrichment.

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/vogue-com-scraper").call(run_input={"mode": "articles", "channels": ["fashion"], "maxItems": 10})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["recordType"], item["title"])
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/vogue-com-scraper').call({ mode: 'articles', channels: ['fashion'], maxItems: 10 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### Resume and recurring updates

- **Resume** (`resumeFromRunId`) continues one interrupted run: paste its run or dataset ID and the actor skips everything already collected there, so you don't pay twice.
- **Incremental mode** (`incrementalMode`) is for scheduled runs over the same scope. Each record is classified `NEW`, `UPDATED` (with `changedFields`), `UNCHANGED` (suppressed, not re-read and not billed unless `emitUnchanged` is on), `REAPPEARED` or `EXPIRED` (only after a run that scanned the whole scope, and only with `emitExpired`). `stateKey` names or shares the stored state. Suppression happens before any detail read, so an unchanged story costs nothing. Add fields to the comparison exemption with `ignoreFieldsForChanges`.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape: the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each record, not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `articles` | `articles`, `runway`, `designers`, or `links`. |
| `channels` | array | `["fashion", "beauty"]` | Sections to walk in articles mode. |
| `searchQueries` | array | `["handbag"]` | Search mode: what to search for. Shopping stories among the hits ship their picks as product rows. |
| `searchSort` | enum | `relevance` | Search mode: `relevance` (the site's ranking) or `newest` (publish date, server-side). |
| `shoppingCategories` | array | `["new-arrivals"]` | Shopping mode: category names (bags, shoes, dresses, jackets, knitwear, tops, pants, skirts, fashion-jewelry), `new-arrivals`, or full shopping links. |
| `productBrands` | array | (none) | Shopping mode: keep only these brands (applied after collection). |
| `productSort` | enum | `site-order` | Shopping mode: `site-order`, `price-asc` or `price-desc` (applied after collection). |
| `seasons` | array | (none) | Season slugs or links for runway mode. |
| `designers` | array | (none) | Designer names, links, or `index` for the full A-Z walk. |
| `startUrls` | array | (none) | Page links for links mode (every shape above). |
| `urls` | array | (none) | Alias for `startUrls`. |
| `fetchDetails` | boolean | `true` | Read each story's page (full text, products), each show's gallery, and each shopping product's store page (description, colors, sizes, image set). |
| `maxItems` | integer | `20` | Stop after this many records. |
| `maxPages` | integer | `0` | Cap feed pages per section or season (`0` = no cap). |
| `resumeFromRunId` | string | (none) | Continue one interrupted run. |
| `incrementalMode` | boolean | `false` | Return only new and changed records on scheduled runs. |
| `stateKey` | string | (none) | Name or share an incremental-mode state. |
| `emitUnchanged` | boolean | `false` | Also return (and bill) unchanged records. |
| `emitExpired` | boolean | `false` | Also return (and bill) expired records. |
| `ignoreFieldsForChanges` | array | `[]` | Incremental mode only: fields excluded from change detection. |
| `proxyConfiguration` | object | Apify Proxy | Connection settings. |
| `mcpConnectors` | array | (none) | Optional: send a summary of each record to apps you authorized under Integrations. |
| `notionParentPageUrl` | string | (none) | Notion connector only: page under which records are created. |
| `maxNotifyListings` | integer | `50` | Cap on items written to each connector per run. |

### Output Example

The Output tab offers one table per record kind: **Articles**, **Shopping picks**, **Runway shows**, **Designers**, plus **All records** (everything in one table) and a **Changes** table (change type, changed fields, first and last seen) for incremental runs.

> Sample shape: values are illustrative placeholders, not from a live record.

```json
{
  "recordType": "article",
  "recordId": "article:sample-story",
  "url": "https://www.vogue.com/article/sample-story",
  "title": "Sample Story Headline",
  "dek": "The standfirst line",
  "section": "Fashion",
  "contentType": "article",
  "authors": ["Sample Byline"],
  "authorUrls": ["https://www.vogue.com/contributor/sample-byline"],
  "pubDate": "2026-10-24T09:30:00-04:00",
  "imageUrl": "https://assets.vogue.com/photos/sample/lead.jpg",
  "keywords": ["fashion", "style"],
  "bodyText": "The full story text...",
  "wordCount": 850,
  "productsFound": 2,
  "changeType": "NEW"
}
```

Show rows carry `designer`, `season`, `seasonName`, `eventDate` (the show date-time), `designersDek` (the creative-director line), the full `reviewText`, `reviewer`, `reviewExcerpt`, `contributors`, `lookCount` and a `looks` list with one entry per look (`lookNumber`, `caption`, `imageUrl`, `imageAlt`, `slideshowUrl`), plus the close-up gallery as `detailShots`/`detailCount` and `relatedShows`. Product rows carry `brand`, `title`, `price`, `currency`, `discountPercent`/`wasPrice` (when on sale), `seller` and every competing offer in `offers` (seller, price, was-price, store link, stock), `merchant`, `retailer`, `merchantUrl`, `offerUrl`, `clickoutUrl`, `imageUrl`/`imageUrls`, `cardFamily`, `editorNote`, `badges`, `sourceArticleUrl`/`sourceCategory` and `position`. Shopping-grid products ship complete from the grid page itself (one page read covers the whole grid); article picks are extracted when the story page is read. Designer rows carry `title`, `designerSlug`, `bio`, `collectionsCount`, `recentShows` (every collection: title, link, image), `relatedArticles` and `promoImageUrl`. Article rows add `contentId`, `publishDate`, `subsections`, `breadcrumbs`, `editorNames`, `isCommerceContent`, `hasBuyButtons`, `affiliateLinksCount` and `templateType`. Products collected with Read detail pages on add the store's `retailerDescription`, `retailerImageUrls` (the store's gallery), `retailerColors`, `retailerSizes`, `retailerSku`/`retailerGtin`, `retailerMaterials` and `retailerAttributes`.

### Plan Requirement

The site is served by Apify's standard connection, so the default settings work on any paid plan. Residential exits are the most reliable choice for large runs and are recommended if a run reads fewer pages than expected; residential traffic is billed to your Apify plan. Apify proxy access needs a paid Apify plan. On a plan without it, the run stops with a clear message instead of an empty result. If nothing could be loaded you get "Could not load any pages (the requests failed), so nothing was collected. This is a connection problem, not an empty result."

### FAQ

#### How much does it cost?

Pay per event. The current rates are shown on the **Pricing** tab (paid Apify plans get lower tiered rates). The events and when each one is charged:

| Event | When it is charged |
| --- | --- |
| Record (`apify-default-dataset-item`) | once for each record pushed to the dataset - articles, products, shows and designers alike |
| Detail enrichment (`detail-enrichment`) | once per returned record whose page was actually read - a story's own page (full text, galleries, shopping picks), a show's page (review, looks) or a product's store page (description, colors, sizes, the store's image set); grid-only rows and unchanged records are never charged |
| Actor Start (`apify-actor-start`) | once per run, per GB of memory |

Unchanged records in incremental mode are neither re-read nor billed. Use **Max items** to cap the cost of any run.

#### Is it legal to scrape Vogue?

This actor collects only publicly available pages. You are responsible for how you use the data: follow the site's terms and the laws that apply to you, and get legal advice if you plan commercial redistribution. Headlines and facts are generally not copyrightable, but article text, photos and brand names may be - the dataset carries them for research and indexing use.

#### How do I get products?

Two ways. **Shopping mode** reads the site's product grids directly - pick categories (new-arrivals, bags, shoes, dresses, jackets, knitwear, tops, pants, skirts, fashion-jewelry) and every product ships with price, was-price, currency, stock and every seller that offers it. With **Read detail pages** on, each product also gets one read of its store's own product page, which adds the store's description, color and size options, SKU/barcode and the store's full image set - the gallery you see on the store page, not the single image the grid carries. **Search mode** runs the site's own search; the shopping stories among the results ship every pick they carry as product rows when Read detail pages is on. Some stores refuse automated readers (several luxury brands do) - those products keep their grid data and are never charged for the attempted read. Pasting any shopping grid link (e.g. /shopping/womens/bags) into Links mode reads that grid too.

#### Does it get product reviews?

No - and neither does the site. Vogue's shopping pages publish editors' picks with prices and sellers, but no customer ratings or reviews anywhere on the site. What the actor ships instead is everything the grids do carry: the current price, the was-price when an item is on sale, stock status, and the full list of sellers with their store links.

#### Can I get only new stories on a schedule?

Yes. Schedule the actor from the **Schedules** tab and turn on **Incremental mode**. Each run then returns only new and updated records; unchanged stories are not re-read and not billed.

#### Why did my run return fewer shopping picks than the article shows?

Shopping picks are emitted while the run still has **Max items** headroom. A story near the cap ships with fewer of its picks. Raise **Max items** to collect them all.

#### Why did my run fail instead of returning an empty dataset?

If every request failed, the run stops with a clear message so "nothing matched" is never confused with "nothing could be read". Run it again in a few minutes. A pasted link that leads to a page the actor cannot read is reported in the run log; if every pasted target fails, the run fails loudly too.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push results into Notion, Linear or Airtable.

### 🔗 Want more fashion data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>👗 <a href="https://apify.com/abotapi/yesstyle-com-scraper"><b>YesStyle Scraper</b></a><br>Scrape YesStyle products by keyword or URL. Extract prices, discounts, ratings, stock...</td><td>🥦 <a href="https://apify.com/abotapi/elcorteingles-es-scraper"><b>El Corte Inglés Scraper</b></a><br>Scrape El Corte Inglés elcorteingles.es products across fashion, electronics, home...</td></tr>
<tr><td>👗 <a href="https://apify.com/abotapi/goat-sneaker-scraper"><b>GOAT Scraper</b></a><br>Scrape GOAT (goat.com), the sneaker and streetwear resale marketplace. Search or paste...</td><td>⚽ <a href="https://apify.com/abotapi/whatnot-scraper"><b>Whatnot Scraper</b></a><br>Scrape Whatnot live and upcoming shows, queued items and lots, and seller profiles...</td></tr>
<tr><td>👗 <a href="https://apify.com/abotapi/showpo-com-scraper"><b>Showpo Scraper</b></a><br>Scrape Showpo women's fashion by keyword, collection or URL. Extract product prices...</td><td>👗 <a href="https://apify.com/abotapi/next-uk-product-scraper"><b>Next.co.uk Scraper</b></a><br>Scrape Next.co.uk: keyword search, category and product-listing walks, full product...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/vogue-com-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

## `mode` (type: `string`):

Articles walks the site's section feeds (fashion news, beauty, culture, shopping picks and more). Search runs the site's own search and returns the matching stories - shopping stories ship their picks as product rows. Shopping reads the site's product grids by category (new arrivals, bags, shoes, dresses and more) with prices and sellers. Runway collects fashion shows for a season, with look galleries. Designers reads designer archive pages. Links reads the specific pages you paste.

## `channels` (type: `array`):

Articles mode: the section feeds to walk, in the order shown. Fashion, Beauty, Culture, Living, Weddings, Shopping, Magazine, Video, and the Homepage highlights feed. Each feed is walked page by page (newest first) until the feed runs out or Max items is reached.

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

Search mode: what to search for, e.g. handbag or winter coat. The site's own search runs server-side and returns the matching stories (8 per page); shopping stories among them ship every pick they carry as product rows with price and seller.

## `searchSort` (type: `string`):

Search mode: the site's server-side result order. Relevance (the default, the site's own ranking) or Newest (publish date, newest first).

## `shoppingCategories` (type: `array`):

Shopping mode: which product grids to read. Category names (bags, shoes, dresses, jackets, knitwear, tops, pants, skirts, fashion-jewelry), new-arrivals, or full shopping links on the site (e.g. /shopping/womens/bags). Each grid page carries its whole catalog - products ship with price, was-price, seller and stock, one entry per seller.

## `productBrands` (type: `array`):

Shopping mode: keep only products of these brands (applied after the grid is collected, so put it together with a category). Case-insensitive, e.g. Chanel.

## `productSort` (type: `string`):

Shopping mode: the order products are returned in. Site order keeps the editors' own placement. Price low to high and Price high to low reorder by the current seller price (applied after collection; the grids themselves have no sort parameter).

## `seasons` (type: `array`):

Runway mode: season slugs or full season links, e.g. spring-2027-ready-to-wear (Spring 2027 Ready-to-Wear). Also accepted: menswear, couture and resort season slugs in the same shape (fall-2026-menswear, spring-2027-haute-couture, resort-2027). A full link like /fashion-shows/spring-2027-ready-to-wear works too. Each season page lists every show it covers, highlights first, then the full A-Z list.

## `designers` (type: `array`):

Designers mode: designer names or links, e.g. louis-vuitton, https://www.vogue.com/fashion-shows/designer/chanel, or a plain name like Chanel (resolved against the site's designer index). The special value 'index' walks the full A-Z designer index instead (thousands of designers, use with Max items).

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

Links mode: any page link on the site - article or slideshow links (/article/..., /slideshow/...), show links (/fashion-shows/<season>/<designer>), season index links (/fashion-shows/<season>), designer pages (/fashion-shows/designer/<slug>), the designer index (/fashion-shows/designers), tag pages (/tag/<name>), contributor pages (/contributor/<name>), and section feeds (/fashion, /beauty, ...). Relative paths are accepted. Entries are read in order. A page you paste here is always actually read; 'Read detail pages' only controls feed-mode enrichment.

## `urls` (type: `array`):

Alias for Page links, accepted under the name other Apify actors use for URL mode. Entries are read in order.

## `fetchDetails` (type: `boolean`):

Read each article's own page (full text, all authors, keywords, photo credits, shopping picks with store links) and each runway show's page (complete look gallery with per-look credits). Turn off for a faster feed-only run. Each enriched article or show is billed once as detail enrichment.

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

Stop after this many records. This is THE cap: the run stops when it is reached or when the sources run out. Shopping picks found inside enriched articles count as records too.

## `maxPages` (type: `integer`):

Advanced. Rarely needed: cap the feed pages read per section or season. Zero means no page cap; Max items still stops the run.

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

Apify Proxy settings. The site is served by the default connection; residential exits are still the most reliable choice for large runs and are recommended if a run reads fewer pages than expected.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue a large pull without returning items already collected there.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns every story, show or designer as NEW. Later runs compare each record against the stored baseline and return only NEW and UPDATED records; unchanged stories are not re-read or re-billed. Turn on Emit unchanged or Emit expired only when you also want those rows returned (and billed). State is kept separately for each section, season, designer and link setup; use State key to name or deliberately share a monitoring campaign.

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or deliberately share state across differently configured runs. Leave empty to let the actor derive a key automatically from the selected sections and links.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return records that have not changed since the last run, marked UNCHANGED. This returns, and bills, extra rows you already have.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return records that were present in a previous run but no longer appear in the sources, marked EXPIRED. Only produced once a run has fully scanned the tracked sources.

## `ignoreFieldsForChanges` (type: `array`):

Incremental mode: changes to only these fields do not mark a record UPDATED. Useful when a field you do not care about moves on every visit.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write or digest. Leave empty to skip; never changes the dataset output.

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "articles",
  "channels": [
    "fashion",
    "beauty"
  ],
  "searchQueries": [
    "handbag"
  ],
  "searchSort": "relevance",
  "shoppingCategories": [
    "new-arrivals"
  ],
  "productSort": "site-order",
  "seasons": [
    "spring-2027-ready-to-wear"
  ],
  "designers": [
    "chanel",
    "louis-vuitton"
  ],
  "startUrls": [
    "https://www.vogue.com/article/mochi-skin",
    "https://www.vogue.com/fashion-shows/spring-2027-ready-to-wear/louis-vuitton"
  ],
  "fetchDetails": true,
  "maxItems": 20,
  "maxPages": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `detail` (type: `string`):

No description

## `articles` (type: `string`):

No description

## `products` (type: `string`):

No description

## `shows` (type: `string`):

No description

## `designers` (type: `string`):

No description

## `changes` (type: `string`):

No description

# 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 = {
    "mode": "articles",
    "channels": [
        "fashion",
        "beauty"
    ],
    "searchQueries": [
        "handbag"
    ],
    "searchSort": "relevance",
    "shoppingCategories": [
        "new-arrivals"
    ],
    "productSort": "site-order",
    "seasons": [
        "spring-2027-ready-to-wear"
    ],
    "designers": [
        "chanel",
        "louis-vuitton"
    ],
    "startUrls": [
        "https://www.vogue.com/article/mochi-skin",
        "https://www.vogue.com/fashion-shows/spring-2027-ready-to-wear/louis-vuitton"
    ],
    "fetchDetails": true,
    "maxItems": 20,
    "maxPages": 0,
    "proxyConfiguration": {
        "useApifyProxy": true
    },
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "maxNotifyListings": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/vogue-com-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 = {
    "mode": "articles",
    "channels": [
        "fashion",
        "beauty",
    ],
    "searchQueries": ["handbag"],
    "searchSort": "relevance",
    "shoppingCategories": ["new-arrivals"],
    "productSort": "site-order",
    "seasons": ["spring-2027-ready-to-wear"],
    "designers": [
        "chanel",
        "louis-vuitton",
    ],
    "startUrls": [
        "https://www.vogue.com/article/mochi-skin",
        "https://www.vogue.com/fashion-shows/spring-2027-ready-to-wear/louis-vuitton",
    ],
    "fetchDetails": True,
    "maxItems": 20,
    "maxPages": 0,
    "proxyConfiguration": { "useApifyProxy": True },
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "maxNotifyListings": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/vogue-com-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 '{
  "mode": "articles",
  "channels": [
    "fashion",
    "beauty"
  ],
  "searchQueries": [
    "handbag"
  ],
  "searchSort": "relevance",
  "shoppingCategories": [
    "new-arrivals"
  ],
  "productSort": "site-order",
  "seasons": [
    "spring-2027-ready-to-wear"
  ],
  "designers": [
    "chanel",
    "louis-vuitton"
  ],
  "startUrls": [
    "https://www.vogue.com/article/mochi-skin",
    "https://www.vogue.com/fashion-shows/spring-2027-ready-to-wear/louis-vuitton"
  ],
  "fetchDetails": true,
  "maxItems": 20,
  "maxPages": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50
}' |
apify call abotapi/vogue-com-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/vogue-com-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/yQsQkfQMbGeTlonhb/builds/AnuUbbJg64uSayQp1/openapi.json