# Njuskalo Scraper (Cheap) (`data_api/njuskalo-scraper-cheap`) Actor

Scrape listings, prices, and images from Njuskalo.hr without getting blocked. Extract cars, apartments, and jobs into structured CSV or JSON files to track market trends and monitor classified ads in real time.

- **URL**: https://apify.com/data\_api/njuskalo-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Njuskalo Scraper

![Njuskalo Scraper](cover.jpg)

Reading Njuskalo by hand means scrolling page after page and copying out each ad's title, price, and location one at a time. This scraper skips all of that. Paste a category or search URL from njuskalo.hr and every ad comes back as a tidy row, with price, area, posted date, seller, and photos already split into fields. It runs fast, costs little, needs no code, and you pay only for the ads you pull.

### What you get

Each ad comes back as one row, grouped into three kinds of data:

- **The ad itself** — `adId`, `adTitle`, `adUrl`, `categoryName`, `adBadges`, and the full `adDescription` when Njuskalo shows it
- **Price and place** — `priceLabel`, `currencyCode`, `areaName`, `publishedDate`
- **Seller and media** — `sellerName`, `coverImage`, `imageLinks`, plus a `collectedAt` timestamp and an `errorMessage` field for any row that could not be read

### Quick start

1. Open njuskalo.hr, pick a category or run a search, and apply your filters.
2. Copy the URL from the address bar.
3. Hit **Try for free**, then paste that URL into **Ad listing URLs**.
4. Set **Ads per URL** to cap how many ads you pull from each link.
5. Press **Start**, then download the results as JSON, CSV, Excel, or XML.

![How it works](how-it-works.jpg)

### Use cases

- **Price research** — track what cars, phones, or apartments are asking across a category and watch where prices move
- **Market sizing** — count how much stock is live in a category or region at any moment
- **Resale and arbitrage** — spot underpriced ads early and compare them against the wider listing pool
- **Lead building** — gather sellers and their `areaName` for a category you work in
- **Dashboards** — feed live Njuskalo data into your own sheet, BI tool, or app

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `targetUrls` | array of strings | Yes | njuskalo.hr category or search URLs to scrape; each one runs through full pagination. Prefilled with an apartments-for-sale search. |
| `resultsLimit` | integer | No | How many ads to pull from each URL. Default `50`. |
| `timeoutSeconds` | integer | No | Seconds to wait on each request before it times out. Default `45`. |

#### Example input

```json
{
    "targetUrls": [
        "https://www.njuskalo.hr/prodaja-stanova"
    ],
    "resultsLimit": 50,
    "timeoutSeconds": 45
}
````

### Output

Every ad on the results page becomes one row, with pagination handled for you up to your limit. Fields Njuskalo does not show for a given ad come back absent rather than guessed.

#### Example output

```json
{
    "adId": "47215983",
    "adTitle": "Prodaja stana, Zagreb, Trešnjevka, 62 m2",
    "priceLabel": "159.000 €",
    "currencyCode": "EUR",
    "areaName": "Zagreb, Trešnjevka",
    "publishedDate": "2026-06-24",
    "adUrl": "https://www.njuskalo.hr/nekretnine/prodaja-stana-zagreb-tresnjevka-oglas-47215983",
    "coverImage": "https://www.njuskalo.hr/image-thumbs/orig/example-cover.jpg",
    "adDescription": "Svijetao trosoban stan na drugom katu, blizu tramvaja i tržnice.",
    "sellerName": "Agencija Dom Plus",
    "imageLinks": [
        "https://www.njuskalo.hr/image-thumbs/orig/example-1.jpg",
        "https://www.njuskalo.hr/image-thumbs/orig/example-2.jpg"
    ],
    "categoryName": "Nekretnine",
    "adBadges": ["Istaknuto", "Provjereno"],
    "collectedAt": "2026-06-30T09:15:00.000000+00:00",
    "errorMessage": null
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `adId` | string | Njuskalo's own identifier for the ad |
| `adTitle` | string | Headline of the ad as shown on Njuskalo |
| `priceLabel` | string | Asking price as printed, including the currency symbol |
| `currencyCode` | string | Three-letter currency code, usually EUR |
| `areaName` | string | Town or region tied to the ad or seller |
| `publishedDate` | string | When the ad went live or was last bumped |
| `adUrl` | string | Direct link to the ad page on Njuskalo |
| `coverImage` | string | Link to the ad's preview thumbnail |
| `adDescription` | string | Full body text of the ad when available |
| `sellerName` | string | Display name or handle behind the ad |
| `imageLinks` | array | Every photo URL from the ad gallery |
| `categoryName` | string | Njuskalo category the ad sits under |
| `adBadges` | array | Promo labels such as Top, Istaknuto, or Provjereno |
| `collectedAt` | string | ISO 8601 timestamp of when the row was captured |
| `errorMessage` | string | Reason an ad could not be read; null when clean |

### Tips for best results

- **Filter on njuskalo.hr first.** A tighter search URL (category, region, price band) gives you a cleaner, more relevant dataset.
- **Start small with `resultsLimit`.** Pull 50 ads to confirm the output fits your pipeline, then raise it for the full run.
- **Any category works.** Cars, real estate, phones, jobs — paste the URL for whichever section you need.
- **Some fields are sparse.** `adDescription` and `imageLinks` only appear when Njuskalo publishes them; those rows still carry everything else.
- **Raise `timeoutSeconds`** if large result pages start timing out.

### How can I use Njuskalo ad data?

**How can I use the Njuskalo Scraper to track classified ad prices?**
Paste a category or search URL and run it on a schedule. Each row carries `priceLabel`, `currencyCode`, `adTitle`, and `publishedDate`, so you can chart asking prices over time and catch new ads the day they post.

**How can I export Njuskalo listings to a spreadsheet?**
Run the scraper, then download the dataset as CSV or Excel. Every ad arrives as a structured row — title, price, area, seller, photos — so it drops straight into a sheet with no cleanup.

**How can I build a Croatian classifieds dataset for market research?**
Feed in one or more category URLs, set `resultsLimit` to the volume you want, and let pagination do the rest. The result is a tidy database of ads (`adId`, `areaName`, `categoryName`, `sellerName`) you can slice by region or category.

**How can I monitor a specific Njuskalo category for new listings?**
Point `targetUrls` at the category you care about and rerun it regularly. Compare the `adId` values between runs to surface only the ads that are new since last time.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `targetUrls` (type: `array`):

One or more njuskalo.hr category, search, or filtered result pages to collect ads from. Set your filters on njuskalo.hr first, then copy the link from the address bar.

## `resultsLimit` (type: `integer`):

Cap on how many ads to pull from each URL you supply.

## `timeoutSeconds` (type: `integer`):

How long to wait on a single request before giving up. Raise it if slow connections cause timeouts.

## Actor input object example

```json
{
  "targetUrls": [
    "https://www.njuskalo.hr/mobiteli"
  ],
  "resultsLimit": 25,
  "timeoutSeconds": 45
}
```

# 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 = {
    "targetUrls": [
        "https://www.njuskalo.hr/prodaja-stanova"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/njuskalo-scraper-cheap").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 = { "targetUrls": ["https://www.njuskalo.hr/prodaja-stanova"] }

# Run the Actor and wait for it to finish
run = client.actor("data_api/njuskalo-scraper-cheap").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "targetUrls": [
    "https://www.njuskalo.hr/prodaja-stanova"
  ]
}' |
apify call data_api/njuskalo-scraper-cheap --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=data_api/njuskalo-scraper-cheap",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Njuskalo Scraper (Cheap)",
        "description": "Scrape listings, prices, and images from Njuskalo.hr without getting blocked. Extract cars, apartments, and jobs into structured CSV or JSON files to track market trends and monitor classified ads in real time.",
        "version": "0.0",
        "x-build-id": "pfsvCDLpgeUOlq7i3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~njuskalo-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-njuskalo-scraper-cheap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/data_api~njuskalo-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-njuskalo-scraper-cheap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/data_api~njuskalo-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-njuskalo-scraper-cheap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "targetUrls"
                ],
                "properties": {
                    "targetUrls": {
                        "title": "Ad listing URLs",
                        "type": "array",
                        "description": "One or more njuskalo.hr category, search, or filtered result pages to collect ads from. Set your filters on njuskalo.hr first, then copy the link from the address bar.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsLimit": {
                        "title": "Ads per URL",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on how many ads to pull from each URL you supply.",
                        "default": 25
                    },
                    "timeoutSeconds": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait on a single request before giving up. Raise it if slow connections cause timeouts.",
                        "default": 45
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
