# Finland Real Estate Scraper \[$0.70/1K💰] | Etuovi + Oikotie (`ahmed_jasarevic/etuovi-scraper`) Actor

Finnish property data from both Etuovi and Oikotie in one run. Scrape real estate listings with price, €/m², energy class, agent contacts and photos for Finland housing market research, price monitoring and lead generation. No portal API key needed.

- **URL**: https://apify.com/ahmed\_jasarevic/etuovi-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.67 / 1,000 listings

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

## Etuovi & Oikotie Scraper — Finland Real Estate Data (Listing Prices, Energy Class, Agents)

**Etuovi & Oikotie Scraper** extracts real estate listings from **etuovi.com** and **oikotie.fi** — Finland's two largest property marketplaces, with tens of thousands of active listings between them — and returns clean, structured JSON. For every listing you get the **price, address, living area, room count, year built, heating system, energy class, all photos, agent contact details, and the listing URL**. It is the Apify actor that scrapes **both portals in a single run with one unified schema** — most other Finland property scrapers cover only one of the two sites. No portal API key, no login, and no browser are required.

Instead of rendering pages, the actor talks directly to the **internal JSON APIs** that the portals' own frontends use, which keeps runs fast and cheap. It runs on the Apify platform, so you get API access, scheduling, webhooks, and proxy rotation out of the box.

### Main Use Cases: Finnish Housing Market Research, Price Monitoring & Lead Generation

- **Finland real estate market research** — pull current listings and asking prices across cities to analyze the Finnish housing market without manual browsing.
- **Real estate investment analysis** — compare properties by price, €/m², area, and construction year with `priceSell`, `debtShareAmount`, and `pricePerSquareMeter` fields.
- **Housing price monitoring & new-listing alerts** — schedule daily runs and track new listings, price changes, and sold/withdrawn signals in any Finnish city.
- **Expat & relocation housing research** — build a shortlist of homes for sale in Helsinki, Tampere, Espoo, or any Finnish municipality when moving to Finland.
- **Real estate agent & agency lead generation** — collect agent names, agency names, and contact details for B2B outreach and CRM enrichment.
- **Property databases & proptech applications** — assemble a clean dataset with GPS coordinates, images, and building details for maps, dashboards, and analytics.

### How It Works: Direct JSON API Access To Etuovi & Oikotie

The actor reverse-engineers the portals' internal JSON APIs instead of rendering pages in a browser:

- **Etuovi**: `GET /api/v2/location/suggestions?q=` resolves a free-text location; `POST /api/v2/announcements/search/listpage` returns search results; `GET /api/v2/announcement/details?friendlyId=` returns full details. The listing page's embedded `window.__INITIAL_STATE__` blob provides all photos and the energy certificate. Requests carry the `X-PORTAL-IDENTIFIER: ETUOVI` header.
- **Oikotie**: a fresh listing page provides rotating auth tokens (`OTA-token`, `OTA-loaded`, `OTA-cuid`), which are then used on `GET /api/cards` (search) and `GET /api/card/{id}` (details).

Because the portals do the filtering server-side, a targeted query — e.g. Helsinki apartments under €400k — returns only matching rows instead of downloading the whole catalogue, which keeps runs fast and cheap.

### Input: Search Finnish Cities, Filter By Price And Size, Or Paste Listing URLs

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `source` | string | No | `both` | Portal(s) to scrape: `both`, `etuovi`, or `oikotie`. Not used in Direct-URL-only mode. |
| `scrapeMode` | string | No | `search` | `search` (by location), `directUrls` (URLs only), or `both`. When URLs are provided and no mode is set, it auto-switches to `directUrls` so no location search runs behind your back. |
| `location` | string | No | `Tampere` | Location to search, e.g. `Helsinki`, `Tampere`, `Lintulampi, Tampere`. Used only in search modes. |
| `maxItems` | integer | No | `50` | Max listings **per source** (Etuovi and Oikotie each). Range 1–1000. |
| `includeDetails` | boolean | No | off (form) / on (API) | Fetch full details: description, agent contact, energy class, all photos. Adds a per-listing `listing-details` charge. When you call via API and omit this field, details default to **on**. |
| `priceMin` / `priceMax` | integer | No | — | Asking-price filter range in EUR. |
| `sizeMin` / `sizeMax` | integer | No | — | Living-area filter range in m². |
| `directUrls` | array | No | `[]` | Scrape specific listings, portal search/filter URLs, or **Etuovi saved-search URLs**. Accepted: an Etuovi listing (`https://www.etuovi.com/kohde/gx2642`), an Oikotie listing (`https://asunnot.oikotie.fi/myytavat-asunnot/24693830`), an Oikotie filter/search URL copied from the address bar, an Etuovi search URL (e.g. `/myytavat-asunnot/tampere/`), or an Etuovi saved-search URL ending in `?haku=...` (resolved via Etuovi's API, so all saved filters apply exactly). |
| `proxy` | object | No | off | Standard Apify proxy configuration. Enable residential groups for very large runs. |

### Output: A Structured Property Dataset For Every Listing

Every dataset item is one listing in a uniform shape, regardless of portal. Main fields:

| Field | Description |
|---|---|
| `source` / `listingId` / `url` | Portal (`etuovi` or `oikotie`), stable listing ID, and direct link |
| `price` / `priceSell` / `debtShareAmount` | Asking price, selling price, and share of housing-company debt (EUR) |
| `pricePerSquareMeter` | Price per square metre (EUR/m²), with details enabled |
| `address` / `city` / `district` / `postalCode` | Full location hierarchy |
| `latitude` / `longitude` | GPS coordinates for mapping and spatial analysis |
| `rooms` / `roomStructure` / `area` / `totalArea` | Room count, Finnish layout string (e.g. `2h + k + kph/s`), living and total area in m² |
| `floor` / `floorCount` / `constructionYear` | Floor, building floors, and build year |
| `heating` / `energyClass` | Heating system description and energy certificate type |
| `maintenanceFee` / `financialFee` | Monthly housing-company charges (EUR) |
| `propertyType` / `ownershipType` / `availabilityDescription` | Property and ownership type, availability |
| `agentName` / `agentPhone` / `agentTitle` / `agencyName` / `agencyPhone` | Selling agent and agency contact details |
| `images` / `mainImage` | Full photo gallery and main photo URL |
| `title` / `description` / `publishedAt` / `status` | Room configuration, full description, publication timestamp, status |

Extended detail fields also appear when `includeDetails` is on: `newProperty`, `housingCompanyName`, `housingCompanyFloorCount`, `plotArea`, `buildingType`, `auxiliarySpace`, `dwellingFeatures`, `periodicChargesAdditionalInfo`. You can download the dataset as JSON, CSV, Excel, HTML, or XML, or pull it via the Apify API.

### Example Input: Scrape Tampere Apartments, Pasted Search URLs, Or Specific Listings

Search by location with filters:

```json
{
  "source": "both",
  "scrapeMode": "search",
  "location": "Tampere",
  "maxItems": 100,
  "includeDetails": true,
  "priceMin": 100000,
  "priceMax": 400000
}
```

Scrape only an Oikotie filter URL you copied from the browser's address bar:

```json
{
  "scrapeMode": "directUrls",
  "directUrls": [
    { "url": "https://asunnot.oikotie.fi/myytavat-asunnot?locations=%5B%5B1676,4,%22Malmi,%20Helsinki%22%5D%5D&cardType=100&buildingType%5B%5D=4&buildingType%5B%5D=8" }
  ]
}
```

Scrape only an Etuovi saved-search URL (all saved filters re-applied exactly):

```json
{
  "scrapeMode": "directUrls",
  "directUrls": [
    { "url": "https://www.etuovi.com/myytavat-loma-asunnot?haku=M2587026111" }
  ]
}
```

### Example Output: One JSON Record Per Listing

```json
{
  "source": "oikotie",
  "listingId": "24693206",
  "url": "https://asunnot.oikotie.fi/myytavat-asunnot/tampere/24693206",
  "title": "2h + k + kph/s + erillinen wc + vh",
  "description": "Harvoin on tarjolla rivitalokaksiota...",
  "price": 198000,
  "priceSell": 183514.68,
  "debtShareAmount": 14485.32,
  "pricePerSquareMeter": 3328,
  "address": "Ollinkatu 9 B, 33400 Tampere",
  "city": "Tampere",
  "district": "Lintulampi",
  "postalCode": "33400",
  "latitude": 61.524635,
  "longitude": 23.675424,
  "rooms": 2,
  "roomStructure": "2h + k + kph/s",
  "area": 59.5,
  "constructionYear": 1991,
  "heating": "Kaukolämpö",
  "energyClass": "E18_D",
  "agentName": "Minna Kivimäki",
  "agentPhone": "050 389 6823",
  "agencyName": "OP Koti",
  "images": ["https://d3ls91xgksobn.cloudfront.net/1200x800,fit,f=webp/etuovimedia/..."],
  "mainImage": "https://d3ls91xgksobn.cloudfront.net/1200x800,fit,f=webp/etuovimedia/...",
  "publishedAt": "2026-09-15T06:29:30Z"
}
```

### Integrations & Automation: Schedule Daily Price Monitoring & New-Listing Alerts

- **Apify API** — run the actor from any app with the Apify REST API or the Apify SDK (JavaScript, Python, CLI).
- **Schedules** — run daily, hourly, or on a custom cron. A daily run of a city search is the recommended pattern for a **new-listing watchlist**: sort-by-newest results are returned by default, so diffing `listingId` against your previous run surfaces new homes within a day.
- **Webhooks** — push each finished dataset to your own endpoint.
- **Zapier / Make / n8n** — trigger runs and send results to Google Sheets, Airtable, Slack, or a database.
- **MCP / AI agents** — the actor is callable through the Apify MCP server (see the section below for agents).

Use recurring runs for recurring value: price monitoring, market snapshots, and new-listing alerts all depend on a schedule. Recurring usage also keeps your Store/MCP recommendations sharp.

### Tips: Cut Costs, Handle Rate Limits & Follow Saved Searches

- **Turn off `includeDetails`** if you only need search-result summaries (price, address, area, main photo) — this roughly halves the request count and avoids the per-listing details charge.
- **Scrape by URL** — set `scrapeMode` to `directUrls`, paste listing, filter, or saved-search URLs, and leave Location empty. The location search is skipped entirely.
- **Enable the Apify proxy** for very large runs. Both portals rate-limit rapid bursts (HTTP 429); the actor paces requests with a per-domain delay and retries.
- **Schedule the actor** (e.g. daily) to track new listings in your target area, and **combine with Apify integrations** to push results to Google Sheets, Slack, or your own database.

### How Much Does It Cost To Scrape Etuovi And Oikotie?

The actor is **pay-per-event** (tiered by your Apify plan):

- **Actor start**: $0.00005 per run.
- **Listing**: $0.0007 per listing written to the dataset.
- **Listing details**: an additional $0.0015 per listing when `includeDetails` is on.

A summary-mode run of 100 listings therefore costs about **$0.07 + run start**; with full details it is about **$0.22 + run start**. Runs use plain HTTP, so Apify compute stays minimal. Free Apify users get a capped **10-item** preview run to evaluate the output; paid users can scrape up to 1,000 items per source.

### Competitive Positioning

Compared to the Etuovi-only and Oikotie-only scrapers on Apify, this actor is the only option that returns **both portals in one run with a unified schema**, which matters because a Finnish home is frequently listed on both sites at once — you no longer need two actors and a merge step.

| Capability | Single-portal competitors | This actor |
|---|---|---|
| Scrapes etuovi.com | Yes (Etuovi-only actors) | Yes |
| Scrapes oikotie.fi | Yes (Oikotie-only actors) | Yes |
| **Both portals in one run, one schema** | No — requires two separate actors | **Yes** |
| Etuovi listing, filter, and `?haku=` saved-search URLs | Etuovi URLs only | Etuovi + Oikotie listing & filter URLs |
| Oikotie search/filter URL from the address bar | Oikotie actors accept listings only | Yes — pasted filter URL is converted to the `/api/cards` call |
| Price, €/m², energy class, agent phone, full photo gallery | Varies by actor | Yes (details mode) |

### Related Actors: European Property Portal Scrapers

This actor is part of a family of European real estate scrapers that together cover the biggest national property portals:

- [Rightmove Scraper — UK Property](https://apify.com/ahmed_jasarevic/rightmove-scraper)
- [SeLoger Scraper — French Property](https://apify.com/ahmed_jasarevic/seloger-scraper)
- [Funda Scraper — Dutch Property](https://apify.com/ahmed_jasarevic/funda-scraper)
- [Idealista Scraper — Spain, Italy & Portugal](https://apify.com/ahmed_jasarevic/idealista-property-scraper)
- [Otodom.pl Scraper — Polish Property](https://apify.com/ahmed_jasarevic/otodom-pl-property-scraper)

### FAQ: Etuovi API, Oikotie API & Finnish Property Data Questions

#### Why use this actor instead of the official API?

**Etuovi has no public API** for listing data — it's a private internal JSON API used by the portal's own frontend, undocumented and not available for external developers. **Oikotie's official Listing API is vendor-only**: it requires a commercial contract with Oikotie, a vendor identifier, a company API key, and onboarding — it exists to let real-estate agencies publish their own listings, not to read competition data. This actor reads the same public listing data both portals show in their browsers, via the internal JSON endpoints, with no contract, no API key, and no login.

#### Do I need an API key or account from Etuovi or Oikotie?

No. Both portals are read through their publicly reachable internal JSON endpoints. You only need your Apify account token to run the actor.

#### What are the alternatives for Finnish property data?

- **This actor** — current for-sale listings from both Etuovi and Oikotie (what's on the market now).
- **Asuntojen hintatiedot** (Ministry of the Environment / KVKL) — realized transaction prices from the past 12 months, free to search.
- **Statistics Finland** — official price indices and €/m² by municipality and postal-code area; aggregate statistics on a release schedule, not listings.
- **National Land Survey property transaction API** — historical transaction data since 1985; requires an agreement, permits, and a yearly fee.
- **Alma Insights (B2B)** — commercial APIs, including Etuovi listing details, aimed at companies.
- **Vuokraovi.com** — the rental side of Finland's housing market (this actor scrapes for-sale listings only).
- **Etuovi-only and Oikotie-only Apify actors** — if you only ever need one portal.

#### Does this actor scrape rental listings?

No. Etuovi.com is sale-only by design (rentals live on the sister site Vuokraovi.com), and the actor's Oikotie path handles for-sale listings (`myytavat asunnot`). For rental data you'd use a Vuokraovi-compatible tool instead.

#### Can I track price drops and new listings over time?

Yes — that's one of the main scheduling patterns. Run the actor daily with a fixed city and filters, keep snapshots of `listingId`/`price`/`publishedAt`, and diff consecutive runs: a new `listingId` is a new listing, a changed `price` is a price update, and a listing that disappears is usually a sale or withdrawal.

#### Which cities and regions are covered?

Any location the portals index. Use the `location` field for cities or districts (e.g. `Helsinki`, `Tampere`, `Oulu`, `Lintulampi, Tampere`), paste an Etuovi search URL or `?haku=` saved-search URL, or paste an Oikotie filter URL from the address bar with any municipality/district filters it carries.

#### How can I compare Helsinki versus Tampere prices?

Run the same input twice with a different `location` and keep `includeDetails` on — the `price` and `pricePerSquareMeter` fields give you directly comparable asking-price data for both cities.

#### Is scraping Etuovi and Oikotie legal?

Scraping publicly available listing data for personal, analytical, or research use is generally acceptable, but you are responsible for respecting the portals' Terms of Service, robots.txt, and applicable data-protection law. This actor is provided as-is for legitimate use cases.

### For AI Agents & LLM Apps

**Purpose**: returns structured JSON records for for-sale property listings from etuovi.com and oikotie.fi (Finnish real estate), one record per listing.

**Minimal working input**:

```json
{ "location": "Tampere", "maxItems": 20, "includeDetails": false }
```

**Variant inputs** — three distinct modes exist:

1. Location search (above), optionally with `source: "etuovi"` or `"oikotie"` and `priceMin`/`priceMax`/`sizeMin`/`sizeMax` filters.
2. Direct URLs: `{ "scrapeMode": "directUrls", "directUrls": [{ "url": "https://www.etuovi.com/kohde/gx2642" }] }`.
3. Both: add `"scrapeMode": "both"` to run a location search plus the provided URLs.

**Main output fields**: `source`, `listingId`, `url`, `title`, `description`, `price`, `priceSell`, `debtShareAmount`, `pricePerSquareMeter`, `address`, `city`, `district`, `postalCode`, `latitude`, `longitude`, `rooms`, `roomStructure`, `area`, `totalArea`, `floor`, `floorCount`, `constructionYear`, `heating`, `energyClass`, `maintenanceFee`, `financialFee`, `agentName`, `agentPhone`, `agentTitle`, `agencyName`, `agencyPhone`, `images`, `mainImage`, `publishedAt`, `status`.

**Behaviors an agent should know**:

- If `scrapeMode` is omitted but `directUrls` are present, the run does direct-URL mode only (location search is skipped).
- If `scrapeMode` requires URLs (`directUrls` or `both`) and no valid URLs are provided, the actor falls back to a location search.
- `maxItems` (default 50, max 1000) applies **per source**, so `source: "both"` can return up to 2× the cap.
- If `includeDetails` is omitted from the API input, it defaults to **true** — full details are fetched and the per-listing `listing-details` charge applies. Pass `includeDetails: false` explicitly for a cheap summary-only run.
- Free (non-paying) Apify accounts are hard-capped at **10 items** per run.
- Known field gaps: Oikotie's API does not expose the agent's phone number (name only); Etuovi search summaries lack city/district until details are fetched; energy class appears only with `includeDetails: true`.
- Unrecognized direct URLs are skipped with a log warning — sanitize URLs before passing them.

**Billing**: pay-per-event — $0.00005 run start + $0.0007 per listing + $0.0015 per listing when `includeDetails` is on (tiered by Apify plan). A 100-listing summary run ≈ $0.07.

### SEO Keywords

etuovi scraper, oikotie scraper, finland real estate scraper, finnish property listings, finland real estate data, finland housing market data, finnish apartment prices, etuovi api alternative, oikotie api alternative, scrape etuovi.com, scrape oikotie.fi, finland property price monitoring, new listing alerts finland, helsinki apartment prices, tampere property listings, espoo real estate, finland property database, finnish real estate market research, real estate investment finland, expat housing finland, price per square meter finland, finland real estate agent leads

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Etuovi (Alma Media Oyj), Oikotie (Sanoma Media Finland), or any of their parent companies**. It accesses **only publicly available listing pages and the portals' public internal JSON endpoints** — there is no login bypass, no CAPTCHA solving, and no use of private credentials. You are responsible for complying with Etuovi's and Oikotie's Terms of Service, robots.txt, and applicable data-protection law (in particular the EU GDPR and the Finnish Act on the Protection of Privacy in Working Life where personal data is concerned). Output may include personal contact data of real-estate agents (names, phone numbers); do not use this data for unsolicited commercial outreach that would violate applicable law (e.g. CAN-SPAM, GDPR, TCPA). This section is a factual disclosure, not legal advice.

# Actor input Schema

## `source` (type: `string`):

Which portal(s) to scrape: etuovi.com, oikotie.fi, or both. Not used in 'Direct URLs only' mode.

## `scrapeMode` (type: `string`):

Search by location, scrape only the direct URLs below, or both. When Direct URLs are provided you can leave Location empty.

## `location` (type: `string`):

Location to search, e.g. 'Tampere', 'Helsinki', 'Lintulampi, Tampere'.

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

Maximum number of listings to scrape per source (etuovi and oikotie each).

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

Fetch full listing details (description, agent contact, year built, heating, energy class, all photos). When disabled, only search-result summaries are returned (faster and cheaper).

## `priceMin` (type: `integer`):

Only listings priced at or above this amount.

## `priceMax` (type: `integer`):

Only listings priced at or below this amount.

## `sizeMin` (type: `integer`):

Only listings with living area at or above this size.

## `sizeMax` (type: `integer`):

Only listings with living area at or below this size.

## `directUrls` (type: `array`):

Scrape specific listings by URL. Supports etuovi.com/kohde/xxx and asunnot.oikotie.fi/myytavat-asunnot/xxx links. When provided, these are scraped in addition to search results.

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "source": "both",
  "scrapeMode": "search",
  "location": "Tampere",
  "maxItems": 50,
  "includeDetails": false,
  "directUrls": [],
  "proxy": {
    "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 = {
    "source": "both",
    "scrapeMode": "search",
    "location": "Tampere",
    "directUrls": [],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/etuovi-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 = {
    "source": "both",
    "scrapeMode": "search",
    "location": "Tampere",
    "directUrls": [],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/etuovi-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 '{
  "source": "both",
  "scrapeMode": "search",
  "location": "Tampere",
  "directUrls": [],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/etuovi-scraper --silent --output-dataset

```

## MCP server setup

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