# Miinto Scraper — Fashion Marketplace Products & Prices (`studio-amba/miinto-scraper`) Actor

Scrape Miinto, the Nordic-led multi-brand fashion marketplace, for product names, brands, prices, discounts and images across 8 European storefronts (Denmark, Sweden, Norway, Netherlands, Belgium, Italy, Germany, France).

- **URL**: https://apify.com/studio-amba/miinto-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (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.20 / 1,000 result scrapeds

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

## Miinto Scraper

Pull product data from Miinto, the Nordic-led multi-brand fashion marketplace. Miinto works like a mid-market boutique layer: hundreds of independent fashion boutiques sell through one storefront per country, sitting between fast fashion and the luxury resale/first-party sites (Vestiaire Collective, Farfetch, Net-a-Porter, Mytheresa) in our other actors. This scraper returns product name, brand, price, currency, discount and image for any search term, across 8 European storefronts.

### How to scrape Miinto data

Give the actor a search term and a country and it returns structured product data -- no manual browsing, no copy-pasting prices off search results pages.

Miinto runs a separate storefront per country (miinto.dk, miinto.se, miinto.no, miinto.nl, miinto.be, miinto.it, miinto.de, miinto.fr), each with its own currency and localized catalogue. Every `/search` page embeds the full result set as structured data inside the page (`__PLP_PRELOADED_STATE__`), so once the actor is past Miinto's session check it reads results directly from that embedded data rather than parsing rendered HTML with CSS selectors -- faster and less likely to break when Miinto tweaks its frontend styling.

Miinto's search endpoint has a quiet anti-bot gate: a plain HTTP request (curl, or a scraper with no real browser behind it) gets back a normal-looking page with an empty product list -- no error, no block page, just zero results. This actor works around that by loading one search page in a real (headless) browser first to establish a valid session, then reusing that session for every page of results after that. You don't need to configure anything for this -- it happens automatically at the start of each run.

If you don't provide a search query, it defaults to `"kjole"` (Danish for "dress") on the Denmark storefront.

#### A note on stock and pricing

Miinto's search results don't expose a dedicated "in stock" field -- `inStock` is set to `true` when the listing shows at least one orderable size, and left as `null` (never `false`) when there's no signal either way. Discounts are calculated from the actual price difference rather than trusted from Miinto's own on-sale flag, which was observed inconsistent during testing (some discounted items weren't flagged as on sale).

### Input

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | Search term, in the local language of the chosen country (e.g. `"kjole"`, `"kleid"`, `"robe"`) |
| `country` | string | Which storefront to search: `dk` (default), `se`, `no`, `nl`, `be`, `it`, `de` or `fr` |
| `maxResults` | integer | Cap on number of products returned (default: 100, max: 5000) |
| `proxyConfiguration` | object | Apify proxy settings. Default is no proxy -- Apify's automatic/datacenter proxy pool was found to hang when connecting to Miinto, while a direct connection from the actor's own IP works reliably |

### What you get back

| Field | Type | Example |
|-------|------|---------|
| `name` | string | `"Ribstrikket kjole med udskæring"` |
| `brand` | string | `"Liu Jo"` |
| `price` | number | null | `759.65` |
| `originalPrice` | number | null | `965.00` (null when not discounted) |
| `discount` | string | null | `"-15%"` |
| `currency` | string | `"DKK"` |
| `productId` | string | `"7f1c9996-bcab-48a7-aac9-d28b02950f89"` |
| `url` | string | `"https://www.miinto.dk/p-ribstrikket-kjole-med-udskaering-7f1c9996..."` |
| `imageUrl` | string | null | `"https://static.miinto.net/475fc710982b54ae0804f5ba2cdfa7cc.webp"` |
| `imageUrls` | array | `["https://static.miinto.net/475fc710982b54ae0804f5ba2cdfa7cc.webp"]` |
| `category` | string | null | `"Midi Dresses"` |
| `categories` | array | null | `["Dresses", "Day Dresses", "Midi Dresses"]` |
| `inStock` | boolean | null | `true` |
| `country` | string | `"dk"` |
| `searchQuery` | string | `"kjole"` |
| `scrapedAt` | string | `"2026-09-10T11:20:00.000Z"` |

### Example output

```json
{
  "name": "Ribstrikket kjole med udskæring",
  "brand": "Liu Jo",
  "price": 889.00,
  "originalPrice": null,
  "discount": null,
  "currency": "DKK",
  "productId": "7f1c9996-bcab-48a7-aac9-d28b02950f89",
  "url": "https://www.miinto.dk/p-ribstrikket-kjole-med-udskaering-7f1c9996-bcab-48a7-aac9-d28b02950f89",
  "imageUrl": "https://static.miinto.net/475fc710982b54ae0804f5ba2cdfa7cc.webp?width=268&height=402",
  "imageUrls": ["https://static.miinto.net/475fc710982b54ae0804f5ba2cdfa7cc.webp?width=268&height=402"],
  "category": "Midi Dresses",
  "categories": ["Dresses", "Day Dresses", "Midi Dresses"],
  "inStock": true,
  "country": "dk",
  "searchQuery": "kjole",
  "scrapedAt": "2026-09-10T11:20:00.000Z"
}
```

### Countries covered

| Country | Domain | Currency |
|---------|--------|----------|
| Denmark | miinto.dk | DKK |
| Sweden | miinto.se | SEK |
| Norway | miinto.no | NOK |
| Netherlands | miinto.nl | EUR |
| Belgium | miinto.be | EUR |
| Italy | miinto.it | EUR |
| Germany | miinto.de | EUR |
| France | miinto.fr | EUR |

### Use cases

- **Price monitoring**: track prices and discounts on specific brands or product types across Miinto's boutique network.
- **Market research**: see which independent boutiques and brands are active on Miinto in a given country.
- **Assortment tracking**: monitor category and brand breadth over time.
- **Cross-retailer comparison**: combine with our other fashion marketplace actors (see below) to compare the same brand's pricing across mid-market and luxury tiers.

### Cost estimate

Each run does one browser page load (to establish a session) plus one lightweight HTTP request per 100 results. A typical 100-result run uses well under a minute of compute and a handful of proxy requests -- costs are dominated by Apify's per-result usage pricing rather than compute or bandwidth. Usage cost only settles once a run reports SUCCEEDED -- reading the dataset mid-run will undercount what the run actually costs.

### Limitations

- Miinto doesn't publish a stock quantity or explicit "in stock" flag at search-result level, so `inStock` reflects whether any size is currently orderable, not exact stock counts.
- Result ordering follows Miinto's own relevance ranking and can shift slightly between runs of the same query, same as any live e-commerce search.
- Only the 8 storefronts listed above are supported. `miinto.fi`, `miinto.pl` and `miinto.es` do not currently resolve.

### Related scrapers

- [Farfetch Scraper](https://apify.com/studio-amba/farfetch-scraper) -- luxury fashion marketplace with per-size stock and style codes
- [Vestiaire Collective Scraper](https://apify.com/studio-amba/vestiairecollective-scraper) -- pre-owned luxury fashion resale
- [Net-a-Porter Scraper](https://apify.com/studio-amba/net-a-porter-scraper) -- luxury womenswear first-party retailer
- [Mytheresa Scraper](https://apify.com/studio-amba/mytheresa-scraper) -- luxury fashion first-party retailer
- [Manor Scraper](https://apify.com/studio-amba/manor-scraper) -- Swiss department store, mid-market fashion and home goods

# Actor input Schema

## `searchQuery` (type: `string`):

Search term in the local language of the chosen country, e.g. 'kjole' (dress) for Denmark, 'kleid' for Germany, 'robe' for France. Leave empty to use a sensible default for the selected country.

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

Which Miinto storefront to search. Prices, currency and assortment are per country.

## `maxResults` (type: `integer`):

Maximum number of products to scrape.

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

Apify Proxy configuration. Default is NO proxy -- verified live that Apify's automatic/datacenter proxy pool hangs when connecting to Miinto, while a direct connection from the actor's own IP works reliably.

## Actor input object example

```json
{
  "searchQuery": "kjole",
  "country": "dk",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searchQuery": "kjole",
    "country": "dk",
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/miinto-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 = {
    "searchQuery": "kjole",
    "country": "dk",
    "maxResults": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/miinto-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 '{
  "searchQuery": "kjole",
  "country": "dk",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call studio-amba/miinto-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/miinto-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/RVlgyisrxrRRiAWTf/builds/fp4GbupYQbFnJpXSJ/openapi.json