# Netshoes Brazil - Products, Prices, Stock & Reviews (`abotapi/netshoes-scraper`) Actor

Scrape sportswear and footwear from netshoes.com.br. Search by keyword with the store's own brand, size, colour and gender filters, or paste product and category links. Returns BRL price, was-price, discount, instalments, stock per size, colour variants, media, specs and reviews with fit feedback.

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

## Pricing

from $1.50 / 1,000 product results

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

## Netshoes Product Scraper (Brazil)

Scrape sportswear, footwear and sports equipment from **netshoes.com.br**, Brazil's largest online
sports retailer.

Search by keyword with the store's own brand, department, product type, size, colour and gender
filters, or paste product, category, brand and search links and scrape them directly. Every product
comes back as one flat row with price in **BRL**, was-price, discount, instalment terms, stock,
colour variants, media and rating, plus optional full specifications and customer reviews with the
store's own **size and fit** feedback.

***

### What you get

#### Always returned (no extra cost per product)

| Field | Example |
|---|---|
| `sku` | `FBA-86LU-026` (one colour of a product, this is the row's identity) |
| `productCode` | `FBA-86LU` (the product family, all colours) |
| `title` | `Tênis Adidas Response Runner 2` |
| `brand` | `Adidas` |
| `url` | `https://www.netshoes.com.br/p/FBA-86LU-026` |
| `department`, `productType` | `Running`, `Tênis` |
| `currency` | `BRL` |
| `price` | `279.99` |
| `originalPrice` | `399.99` |
| `discountAmount`, `discountPercent`, `onSale` | `120.0`, `30`, `true` |
| `paymentMethod`, `paymentMethodPrice` | `PIX`, `265.99` |
| `installments` | `{"count": 4, "amountEach": 70.0, "total": 279.99, "interestFree": true}` |
| `installmentPlans` | every plan the store offers, 1x through 10x |
| `sellerName`, `soldByStore` | `Netshoes`, `true` (marketplace sellers are named) |
| `inStock`, `sizes` | `true`, `["34", "35", ..., "43"]` |
| `colorVariants` | the same product in its other colours, with links |
| `freeShipping`, `fastFulfilment`, `additionalDeliveryDays`, `preSale` | shipping policy for this product |
| `badges` | `["LANÇAMENTO", "NetsGO"]` |
| `featuredImage`, `images` | full gallery |
| `rating`, `reviewCount` | `4.88`, `180` |

#### With **Read each product's page** on

`description`, `longDescription`, `specs` (every attribute the store publishes: material,
technology, drop, pronation, terrain, weight, warranty, origin), `highlights`, `material`,
`technology`, `weightGrams`, `dimensionsCm`, `origin`, `warranty`, `releaseDate`, `sizeType`,
`sizeGuideAvailable`, `thumbnails`, `videos`, named `color`, and:

- `variants` - **stock per size**, each with its own `sku`, `price`, `originalPrice`, `available`
  and `ean`
- `sizesInStock` - just the sizes you can actually buy right now

#### With **Fetch customer reviews and fit feedback** on

- `reviews` - `rating`, `text`, `authorName`, `recommends`, `publishedAt`, `photos`
- `ratingHistogram` - votes and percentage per star
- `percentRecommended`
- `fitFeedback` - the store's size and fit surveys. Each topic carries the wording of its own
  five-point scale, so you can tell **which way** it leans without guessing:

  ```json
  [{"topic": "Tamanho",  "average": 2.95, "midpoint": 3.0,
    "scaleLow": "Justo", "scaleMid": "Na Medida", "scaleHigh": "Largo", "responses": 180},
   {"topic": "Conforto", "average": 3.91, "midpoint": 3.0,
    "scaleLow": "Desconfortável", "scaleMid": "Confortável",
    "scaleHigh": "Muito Confortável", "responses": 180}]
  ```

  An average **below** `midpoint` on `Tamanho` means buyers found it runs tight.
- `questions` - answered customer questions about the product

***

### Two modes

#### Search mode

Set **Mode** to *Search by keyword* and give one or more keywords. Netshoes is a Brazilian store, so
**Portuguese keywords match far more**: `tenis adidas` finds Adidas trainers, `adidas sneakers` finds
almost nothing.

One quirk worth knowing: Netshoes maps a handful of popular phrases to a **curated campaign page**
rather than a product list. `tenis corrida`, for example, returns the store's "CORRIDA" promotional
page, which has no product grid at all, and no sort, page or search parameter escapes it. Ordinary
multi-word searches are unaffected (`tenis adidas` returns 3,218 matches, `chuteira campo` returns
11,346). When it happens the run **says so and names the page**, rather than reporting it as an empty
catalogue or as a connection failure. Reword the keyword, or paste the category link you want in URL
mode.

#### URL mode

Set **Mode** to *Scrape pasted links* and paste any mix of:

| Link | What you get |
|---|---|
| `https://www.netshoes.com.br/p/tenis-adidas-response-runner-2-FBA-86LU-026` | that one product, always with full detail |
| `https://www.netshoes.com.br/busca?q=tenis%20adidas` | every result for that keyword |
| `https://www.netshoes.com.br/running/tenis/adidas` | every product in that category or brand |
| `https://www.netshoes.com.br/especiais/corrida` | every product on that campaign page |
| `.../busca?q=tenis&page=4` | starts at page 4 instead of page 1 |

Every listing shape above is the same result page underneath, so they all accept the same filters
and the same result limits. Tracking parameters (`mi`, `psn`, `utm_*`) are stripped, so two links
that differ only by attribution are treated as one search.

***

### Filters

All filters apply to **both** modes. Type each value the way the store shows it: the store's own
filter list is read at run time, so spelling, accents and capitalisation are matched for you, and
`new balance`, `New Balance` and `new-balance` all reach the same brand.

- **Brand** - `Nike`, `Adidas`, `Olympikus`, `New Balance`, ...
- **Department** - `Running`, `Futebol`, `Academia`, ...
- **Product type** - `Tenis`, `Chuteiras`, `Camisetas`, `Chinelos`, ...
- **Size** - `40`, `M`, `GG`. Brazilian footwear sizes are numeric and differ from EU and US sizing.
- **Colour** - Portuguese colour names (`Preto`, `Branco`, `Azul`). A product sold as `Preto+Branco`
  matches either of its colours.
- **Gender** - `feminino`, `masculino`, `menina`, `menino`, `bebe-menina`, `bebe-menino`
- **Minimum / Maximum price** in BRL
- **Only products in stock**, **Only discounted products**
- **Sort by** - most popular, best sellers, new releases, offers, best rated, price low to high,
  price high to low

Two behaviours worth knowing:

- A value this search does not offer is **reported in the log** and then applied to the results
  anyway, so an unrecognised value returns **fewer** rows, never more. It is never guessed at,
  because an invented filter value makes this store return zero results with no error at all.
- A filter a pasted link already carries is left exactly as you pasted it, rather than being
  overwritten by a run-level default.

***

### Incremental mode and Resume

Two different things, both in the **Resume and recurring updates** section.

**Incremental mode** is for scheduled monitoring. The first run returns everything as `NEW`; later
runs return only `NEW`, `UPDATED` and `REAPPEARED`, with `changedFields` naming exactly what moved.
That makes it a cheap way to watch price drops and restocks, because you are not billed for rows
that did not change. `UNCHANGED` and `EXPIRED` rows are off by default and both add billed rows when
you turn them on. `EXPIRED` is only produced once a run has fully scanned the tracked search, never
when **Max products** capped it or Resume was used, so a partial run can never tombstone products
that are still on sale.

State is kept per search and filter setup, so two different searches never mix. Use **State key** to
name a campaign, or to deliberately share state across runs.

**Resume from a previous run** continues one specific interrupted run: paste its run or dataset ID
and products already collected there are skipped and not re-billed.

***

### Connection, speed and cost

Netshoes refuses ordinary connections on its result and product pages. The default Connection
setting is correct and needs no change. At the start of every run, the actor opens **one short
browser session** with the store (~20-40 seconds): the store clears it on its own, and every page
after that — result pages, product pages, reviews — is read over a plain connection at full speed
(seconds per page). You do nothing; the session opens and closes by itself.

If that session cannot be opened (rare, or the account's plan misses the connection), the run
falls back to the previous behaviour: it starts on the cheapest connection and, the first time a
page is refused, moves **once** to Apify Proxy's enhanced group and stays there for the rest of
the run. That fallback is billed on your own Apify plan and costs more per request, which is
another reason to leave the group list empty.

Consequences:

- **Typical run:** one ~20-40s session at the start, then seconds per page, including full
  per-product detail and reviews.
- **Fallback run (rare):** a page can take up to a minute on the enhanced connection. If your plan
  does not include it, the run says so explicitly and fails rather than returning an empty dataset
  that looks like an empty search.

A run that could not read any pages **fails** with a connection message. A run that read pages and
genuinely matched nothing succeeds with zero rows. These two are never reported the same way.

#### Keeping a run cheap

- A result page carries about 100 products and already includes price, discount, sizes, images and
  rating. Leave both per-product toggles **off** and you pay one page for every hundred products.
- **Read each product's page** and **Fetch customer reviews** each need one extra page per product
  and are billed with one *Product page detail* event per product returned. They share that one
  page, so turning both on costs the same as turning on either.
- Use **Incremental mode** for anything recurring.

***

### Scope: Brazil only

This Actor covers **netshoes.com.br** only, and that is the whole of Netshoes today.

Netshoes previously operated Mexican and Argentine storefronts. Both were checked live on
2026-08-27 and **neither exists any more**: `netshoes.com.mx` and `netshoes.com.ar` both resolve to
a single address that accepts a connection but serves no site at all, from two independent vantage
points including one inside Brazil. There is no sibling storefront and no shared backend left to
support, so there is no country selector in the input, and links to those domains are rejected
rather than silently treated as Brazilian ones.

***

### What this Actor deliberately does not return

- **A delivery estimate or shipping cost for your address.** Netshoes only quotes those after you
  enter a postcode (CEP) on the product page, and it publishes no per-address quote in the page
  itself. What the page *does* publish is returned instead: `freeShipping`, `fastFulfilment`,
  `additionalDeliveryDays` and `preSale`.
- **Every review of a product.** A product page publishes only its most recent reviews inline
  (usually about a dozen) however many it has in total. Those are returned along with the complete
  aggregates (`reviewCount`, `ratingHistogram`, `percentRecommended`, `fitFeedback`), which cover
  all of them. `reviewsTruncated` is `true` on any product with more, so you never have to infer it
  from a count mismatch.
- **The email address of a customer who asked a question.** The store publishes it; it is a private
  individual's contact detail with no bearing on the product, so it is dropped and never reaches the
  dataset. The question, the answer and who answered are all returned.
- **Prices for a colour you are not looking at.** `colorVariants` carries each other colour's code,
  name, image, link and availability, but the store only prices the colour whose page you are on.
  Follow the link to price one.

***

### Output sample

```json
{
  "sku": "FBA-86LU-026",
  "productCode": "FBA-86LU",
  "title": "Tênis Adidas Response Runner 2",
  "brand": "Adidas",
  "url": "https://www.netshoes.com.br/p/FBA-86LU-026",
  "department": "Running",
  "productType": "Tênis",
  "genders": ["Feminino", "Masculino"],
  "categoryPath": ["Running", "Tênis", "Adidas", "Preto"],
  "currency": "BRL",
  "price": 279.99,
  "originalPrice": 399.99,
  "discountAmount": 120.0,
  "discountPercent": 30,
  "onSale": true,
  "paymentMethod": "PIX",
  "paymentMethodPrice": 265.99,
  "installments": {"count": 4, "amountEach": 70.0, "total": 279.99, "interestFree": true},
  "sellerName": "Netshoes",
  "soldByStore": true,
  "inStock": true,
  "sizes": ["34", "35", "36", "37", "38", "39", "40", "41", "42", "43"],
  "sizesInStock": ["34", "35", "36", "37", "38", "39", "40", "41", "42", "43"],
  "variants": [
    {"sku": "FBA-86LU-026-34", "size": "34", "available": true,
     "price": 279.99, "originalPrice": 399.99, "ean": "4069997267496"}
  ],
  "color": {"name": "Preto+Branco", "primaryName": "Preto", "primaryHex": "#000000",
            "secondaryName": "Branco", "secondaryHex": "#ffffff"},
  "colorVariants": [
    {"sku": "FBA-86LU-036", "colorName": "Marinho+Branco",
     "url": "https://www.netshoes.com.br/p/FBA-86LU-036", "available": true}
  ],
  "freeShipping": true,
  "fastFulfilment": true,
  "additionalDeliveryDays": 0,
  "preSale": false,
  "badges": ["LANÇAMENTO", "NetsGO"],
  "material": "Têxtil",
  "technology": "Cloudfoam",
  "weightGrams": 690,
  "origin": "Nacional",
  "sizeGuideAvailable": true,
  "rating": 4.88,
  "reviewCount": 180,
  "percentRecommended": 98,
  "fitFeedback": [
    {"topic": "Tamanho", "average": 2.95, "midpoint": 3.0,
     "scaleLow": "Justo", "scaleMid": "Na Medida", "scaleHigh": "Largo", "responses": 180}
  ],
  "reviewsTruncated": true,
  "changeType": "NEW",
  "changedFields": [],
  "firstSeenAt": "2026-08-27T12:00:00Z",
  "lastSeenAt": "2026-08-27T12:00:00Z",
  "scrapedAt": "2026-08-27T12:00:00Z"
}
```

Reviewer names and review text are omitted from this sample on purpose; the dataset returns them
as the store publishes them.

***

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

Optionally pipe results into Notion, Linear, Airtable or Apify via MCP connectors, in the
**Export to your apps (MCP connectors, optional)** section of the input. Each connector receives a
condensed summary per product; the complete record always stays in the dataset, so nothing is lost
if you leave this off.

- `mcpConnectors` - the MCP connectors to export this run's products into (Notion, Linear,
  Airtable, Apify). Leave it empty and nothing is exported.
- `notionParentPageUrl` - Notion connector only: the page under which one child page per product is
  created. Required when `mcpConnectors` includes Notion, ignored otherwise.
- `maxNotifyListings` - how many products are exported to each connector in one run, default 50.
  This caps the export only; it never changes what the dataset returns.

Export runs after the dataset is complete and is best-effort: if a connector is unreachable the
run still succeeds with a warning, and your products are still in the dataset.

***

### Pricing

You are charged for:

- **Product result** - each product returned in the dataset
- **Product page detail** - once per product whose own page was read, for full description,
  specifications, per-size stock, extra media or reviews. Only charged for products that actually
  reach the dataset, so a run in Incremental mode is never billed for a product it suppressed, and
  a product whose page the store refused is returned from its result card and is not billed either.
- **Actor start** - once per run, scaled by memory

One case is worth calling out before you run it: a **pasted product link** in URL mode always reads
the product page, because there is no result card behind it to fall back on. So a product link is
always billed one *Product page detail* event, even with **Read each product's page** switched off.
Search mode and pasted category, brand or search links honour the toggle exactly as written.

# Actor input Schema

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

Choose 'search' for keywords plus filters, or 'url' to scrape pasted Netshoes links. Each mode reads only its own field below.

## `queries` (type: `array`):

Only used when mode = search, ignored in URL mode. One or more keywords, for example 'tenis adidas', 'chuteira campo' or 'camisa flamengo'.

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

Only used when mode = url, ignored in search mode. Product links under /p/, search links under /busca and category or brand paths such as /running/tenis/adidas are all accepted. A listing link that already carries page=N starts at that page rather than at page 1.

## `brand` (type: `string`):

Optional. Keep only products of this brand, for example 'Nike', 'Adidas', 'Olympikus' or 'New Balance'.

## `category` (type: `string`):

Optional. Keep only products in this department, as the store names it, for example 'Running', 'Futebol', 'Academia' or 'Casual'.

## `productType` (type: `string`):

Optional. Keep only this type of product, as the store names it, for example 'Tenis', 'Chuteiras', 'Camisetas' or 'Chinelos'.

## `size` (type: `string`):

Optional. Keep only products offered in this size, for example '40', 'M' or 'GG'. Brazilian footwear sizes are numeric and differ from EU and US sizing.

## `color` (type: `string`):

Optional. Keep only products in this main colour, in Portuguese as the store names it, for example 'Preto', 'Branco', 'Azul' or 'Vermelho'. A product sold in a two-colour combination such as 'Preto+Branco' matches either of its colours.

## `gender` (type: `string`):

Optional. Keep only products for this audience. The store's own list, in Portuguese: feminino (women), masculino (men), menina (girls), menino (boys), bebe-menina (baby girls), bebe-menino (baby boys).

## `minPrice` (type: `integer`):

Optional. Only keep products whose current price is at or above this amount, in Brazilian reais. The store does not offer a working price filter on its own result pages, so this is applied to the price this Actor reads for each product.

## `maxPrice` (type: `integer`):

Optional. Only keep products whose current price is at or below this amount, in Brazilian reais. Applied to the price this Actor reads for each product, for the same reason as the minimum above.

## `inStockOnly` (type: `boolean`):

Optional. Keep only products that can be bought right now. Sold-out products are returned by default so you can track them.

## `onSaleOnly` (type: `boolean`):

Optional. Keep only products whose current price is below their was-price.

## `sortBy` (type: `string`):

How the store orders its result pages. Netshoes mixes a small number of promoted products into every ordering, so the first rows of a page are not always in strict order.

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

Read every product's own page for full description, specifications, material, technology, weight and dimensions, origin, warranty, per-size stock and EANs, named colour variants and the full image gallery. Off by default because it costs one extra page per product. A pasted product link always reads the product page, because there is no result card behind it, so a product link is always billed one 'Product page detail' event whatever this toggle says.

## `fetchReviews` (type: `boolean`):

Also collect customer reviews for each product: rating, text, author name, recommendation and date, plus the per-star breakdown, the share of reviewers who recommend it, and the store's size and fit surveys (fit, comfort, quality and weight, each with the wording of its own scale). Also reads the product page, so it carries the same per-product surcharge as the toggle above. The average rating and review count are always returned without this.

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

Cap on how many individual reviews are collected for each product when 'Fetch customer reviews and fit feedback' is on. Newest first. A Netshoes product page publishes only its most recent reviews inline (usually about a dozen) however many it has in total, so 'reviewsTruncated' is set on any product with more.

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

Maximum number of products to return across the whole run. This is the run's cap. Use 0 for unlimited.

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

Maximum number of result pages to take per keyword or link. Each page carries about 100 products. 0 = unlimited; the run then stops only at Max products, or when there are no more results.

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

Paste a previous run ID or dataset ID to continue a large catalogue pull without returning or charging for products already collected there. Use this after an interrupted run. For recurring monitoring of the same search, use Incremental mode below instead.

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

Turn this on for daily or recurring monitoring. The first run returns every matching product as NEW. Later runs normally return only NEW, UPDATED and REAPPEARED products, which makes it a cheap way to watch price drops and restocks. Turn on 'Emit unchanged' or 'Emit expired' only when you also want those rows returned (and billed). State is kept separately for each search and filter setup; use State key to name or deliberately share a monitoring campaign. To continue one specific interrupted run instead, use Resume from a previous run above.

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

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently configured runs. Leave empty to derive a key automatically from the search and filter settings, so two different searches never mix state.

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

Off by default. Turn on to also return products that have not changed since the last run, marked UNCHANGED. This returns, and bills, extra rows you already have, so leave it off unless you want a full snapshot every run.

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

Off by default. Turn on to also return products that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search, never when Max products capped it or Resume was used. This returns, and bills, extra rows, so leave it off unless you need expiry tracking.

## `proxy` (type: `object`):

Connection used for every request. Leave the default; the run escalates on its own when the store refuses a page.

## `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 page per product; other connectors get a best-effort write or digest. Each connector receives a condensed summary per product, not the full record; the complete record always stays in the dataset. Leave empty to skip; this never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

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

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

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

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

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "tenis adidas"
  ],
  "urls": [
    "https://www.netshoes.com.br/busca?q=tenis%20adidas",
    "https://www.netshoes.com.br/p/tenis-adidas-response-runner-2-FBA-86LU-026"
  ],
  "gender": "",
  "inStockOnly": false,
  "onSaleOnly": false,
  "sortBy": "relevance",
  "fetchDetails": false,
  "fetchReviews": false,
  "maxReviewsPerProduct": 20,
  "maxItems": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (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": "search",
    "queries": [
        "tenis adidas"
    ],
    "urls": [
        "https://www.netshoes.com.br/busca?q=tenis%20adidas",
        "https://www.netshoes.com.br/p/tenis-adidas-response-runner-2-FBA-86LU-026"
    ],
    "inStockOnly": false,
    "onSaleOnly": false,
    "fetchDetails": false,
    "fetchReviews": false,
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/netshoes-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": "search",
    "queries": ["tenis adidas"],
    "urls": [
        "https://www.netshoes.com.br/busca?q=tenis%20adidas",
        "https://www.netshoes.com.br/p/tenis-adidas-response-runner-2-FBA-86LU-026",
    ],
    "inStockOnly": False,
    "onSaleOnly": False,
    "fetchDetails": False,
    "fetchReviews": False,
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/netshoes-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": "search",
  "queries": [
    "tenis adidas"
  ],
  "urls": [
    "https://www.netshoes.com.br/busca?q=tenis%20adidas",
    "https://www.netshoes.com.br/p/tenis-adidas-response-runner-2-FBA-86LU-026"
  ],
  "inStockOnly": false,
  "onSaleOnly": false,
  "fetchDetails": false,
  "fetchReviews": false,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/netshoes-scraper --silent --output-dataset

```

## MCP server setup

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