# OfficeRentInfo Scraper — European Office & Warehouse Listings (`studio-amba/officerentinfo-scraper`) Actor

Scrape office, serviced-office, coworking, and warehouse listings from the officerentinfo.\* network across 12 European markets: building name, location, available space, rental fee, service charge. No login required.

- **URL**: https://apify.com/studio-amba/officerentinfo-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Real estate, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## OfficeRentInfo Scraper

Scrape commercial real estate listings from the officerentinfo.com portal network: office buildings, serviced offices, coworking spaces, and warehouses across 12 European markets.

The network (run by Online Real Assets) operates a dedicated portal per country. This actor covers all of them with one input: pick a country, optionally a city, and get structured listing data as JSON, CSV, or Excel.

### Markets covered

| Country | Offices | Warehouses |
|---------|---------|------------|
| Austria | officerentinfo.at | — |
| Belgium | officerentinfo.be | warehouserentinfo.be |
| Czechia | officerentinfo.cz | warehouserentinfo.cz |
| France | officerentinfo.fr | warehouserentinfo.fr |
| Croatia | officerentinfo.com.hr | — |
| Hungary | officerentinfo.hu | warehouserentinfo.hu |
| Luxembourg | officerentinfo.lu | warehouserentinfo.lu |
| Poland | officerentinfo.pl | warehouserentinfo.pl |
| Romania | officerentinfo.ro | warehouserentinfo.ro |
| Serbia | officerentinfo.rs | warehouserentinfo.rs |
| Slovakia | officerentinfo.sk | warehouserentinfo.sk |
| United Kingdom | officerentinfo.co.uk | — |

The UK portal has a small inventory compared to the Central European markets. The strongest coverage is in Poland, Hungary, Czechia, Romania, and Serbia.

### Why use it

- Market research: track available office and warehouse space per city or country.
- Brokerage and agency work: build a supply overview without visiting hundreds of building pages.
- Lead generation: every listing links to a building page with the listing agent.
- Investment analysis: available space, occupancy rates, and published rental fees per building.

### What you get

One record per building listing. Card data (name, location, available space, headline fee where published) comes from the listing pages. Turn on `fetchDetails` to also fetch each building's detail page, which adds rental fee, service charge, minimum rental period, total building space, occupancy rate, add-on factor, and building status where the lister published them.

A note on prices: commercial landlords mostly keep fees on request. On listing cards a published fee is rare; detail pages carry one more often (Hungary is the best-covered market). The `price` field is null when no fee is published, and `currency` plus `priceUnit` always accompany a price. Commercial rents on this network are quoted per m2 per month; the actor captures the unit as stated and never guesses or converts currencies.

### Input options

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `country` | string | `pl` | Market to scrape: `at`, `be`, `cz`, `fr`, `hr`, `hu`, `lu`, `pl`, `ro`, `rs`, `sk`, `uk` |
| `searchQuery` | string | — | City to filter on, e.g. `Warsaw`, `Budapest`, `Kraków`. Empty = whole country |
| `segment` | string | `office` | `office` or `warehouse`. Warehouses are available for BE, CZ, FR, HU, LU, PL, RO, RS, SK |
| `maxResults` | integer | `100` | Maximum number of unique listings to return (hard cap 5000) |
| `fetchDetails` | boolean | `false` | Also fetch each building's detail page. This flag changes how complete records are: most price and building-spec fields are only available with it on. One extra request per listing |
| `proxyConfiguration` | object | Apify automatic | No anti-bot on this network; the automatic proxy is enough |

If the portal does not recognize the city you asked for, it returns country-wide results instead of an error. The actor detects this, logs a warning, and tags every affected item with `locationFilterApplied: false` so you never mistake country-wide data for a city filter.

### Output fields

| Field | Example | Description |
|-------|---------|-------------|
| `name` | `Adgar Plaza One` | Building name |
| `url` | `https://www.officerentinfo.pl/offices-office-buildings-for-rent/warsaw/mokotow/adgar-plaza-one` | Listing detail page |
| `source` | `officerentinfo.pl` | Portal domain |
| `country` | `PL` | Market, ISO 3166-1 alpha-2 |
| `segment` | `office` | `office` or `warehouse` |
| `listingType` | `rent` | Always `rent` (the network lists rentals only) |
| `buildingId` | `15121` | Portal-internal building ID |
| `city` | `Warsaw` | City |
| `district` | `Mokotow` | District, when shown |
| `address` | `Puławska 431` | Street address, when published |
| `surface` | `400` | Available space in m2 (lower bound of a range) |
| `surfaceMax` | `1200` | Upper bound of the available-space range, when shown |
| `surfaceUnit` | `m2` | Always m2 |
| `price` | `14.5` | Headline rental fee, null when on request |
| `currency` | `EUR` | Currency of the fee, never converted |
| `priceEur` | `14.5` | Fee in EUR, only when the source quotes EUR |
| `priceUnit` | `EUR/m2/month` | Fee unit exactly as stated |
| `priceRaw` | `14.5 €/m2/month + VAT` | Fee text as displayed |
| `imageUrl` | `https://www.officerentinfo.pl/media/cache/...jpeg` | Primary photo |
| `locationFilterApplied` | `true` | False when the city filter was dropped by the portal |
| `serviceChargeRaw` | `HUF 2,550 /m2/month + VAT` | Service charge, with `fetchDetails` |
| `minRentalPeriod` | `36 month` | Minimum lease term, with `fetchDetails` |
| `surfaceTotal` | `15800` | Total building space in m2, with `fetchDetails` |
| `surfaceMinRentable` | `297` | Smallest rentable unit in m2, with `fetchDetails` |
| `occupancyRate` | `98%` | Occupancy, with `fetchDetails` |
| `addOnFactor` | `8.4 %` | Common-area factor, with `fetchDetails` |
| `buildingStatus` | `Exist` | Building status, with `fetchDetails` |
| `buildingCategory` | `Office to rent` | Portal category, with `fetchDetails` |
| `scrapedAt` | `2026-08-18T09:12:00.000Z` | Scrape timestamp |

### Example output

```json
{
    "name": "BC 99 - Balance Building",
    "url": "https://www.officerentinfo.hu/office/bc-99-balance-building",
    "source": "officerentinfo.hu",
    "country": "HU",
    "segment": "office",
    "listingType": "rent",
    "buildingId": "4213",
    "city": "Budapest",
    "district": "District 13",
    "address": "Váci út 99",
    "surface": 297,
    "surfaceMax": 297,
    "surfaceUnit": "m2",
    "price": 14.5,
    "currency": "EUR",
    "priceEur": 14.5,
    "priceUnit": "EUR/m2/month",
    "priceRaw": "14.5 €/m2/month + VAT",
    "imageUrl": "https://www.officerentinfo.hu/media/cache/38/default_small/uploads/media/default/0001/23/sample.jpeg",
    "locationFilterApplied": true,
    "searchQuery": "budapest",
    "serviceChargeRaw": "HUF 2,550 /m2/month + VAT",
    "minRentalPeriod": "36 month",
    "surfaceTotal": 15800,
    "surfaceMinRentable": 297,
    "occupancyRate": "98%",
    "addOnFactor": "8.4 %",
    "buildingStatus": "Exist",
    "buildingCategory": "ESG, Energy-efficient office building",
    "scrapedAt": "2026-08-18T09:12:00.000Z"
}
```

### How to scrape OfficeRentInfo data

1. Open the actor on the Apify platform and press Try for free.
2. Pick a country (for example Poland) and optionally type a city into the location field.
3. Choose the segment: offices or warehouses.
4. Set `maxResults` and press Start.
5. When the run finishes, download the dataset as JSON, CSV, or Excel from the Output tab, or read it via the Apify API.

For a full price and building-spec dataset, switch `fetchDetails` on. Without it the actor stays on the listing pages, which is faster and cheaper but carries fewer price fields.

To automate, schedule the actor daily or weekly and diff the datasets: new `buildingId` values are new supply on the market, and changes in `surface` per building track space being absorbed or released.

### Cost estimate

Pricing is per result plus a small run start fee. In listing mode the actor fetches roughly one page per 100 listings, so platform usage is minimal: expect several thousand results per $1 of usage on top of the per-result price. With `fetchDetails` on, each listing costs one extra page fetch; usage stays low because the pages are plain HTML with no browser rendering.

A run's usage cost only settles after the run reports SUCCEEDED. A cost read mid-run shows only the partial usage so far and underestimates the final number, so always judge cost on finished runs.

### Limitations

- Published rental fees are sparse. That is the market, not a scraper gap: most commercial listers keep fees on request. Fields are null rather than guessed.
- The network is rent-only. There are no for-sale listings to scrape.
- Warehouse portals do not exist for Austria, Croatia, or the UK; the actor tells you so instead of silently returning offices.
- The UK portal exists but carries a thin inventory.
- Listing pages repeat some featured buildings across sections; the actor dedupes by canonical URL, so counts are unique buildings.

# Actor input Schema

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

Market to scrape. Each country has its own portal (e.g. officerentinfo.pl, officerentinfo.hu). Croatia is officerentinfo.com.hr, the UK is officerentinfo.co.uk (thin inventory).

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

City to filter on, e.g. 'Warsaw', 'Kraków', 'Budapest', 'Prague'. Diacritics are handled. Leave empty to scrape the whole country. If the portal does not know the city, it returns country-wide results and each item is tagged locationFilterApplied=false.

## `segment` (type: `string`):

Property segment. 'office' covers office buildings, serviced offices, and coworking. 'warehouse' uses the warehouserentinfo.\* sibling portals (available for BE, CZ, FR, HU, LU, PL, RO, RS, SK — not AT, HR, UK).

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

Maximum number of unique building listings to return. A city typically has tens to a few hundred listings; a full country a few hundred to a thousand.

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

OFF by default, and this flag changes how COMPLETE each record is: rental fees are rarely printed on listing cards (commercial listers mostly keep them on request), so price, serviceChargeRaw, minRentalPeriod, surfaceTotal, occupancyRate, and buildingStatus are mostly only filled when this is on. Costs one extra request per listing, so runs take proportionally longer.

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

No anti-bot was found on any portal of the network (direct HTTP with a browser User-Agent works — see docs/site-recon/officerentinfo.md) — Apify Proxy automatic is enough. Leave the default unless you see blocking.

## Actor input object example

```json
{
  "country": "pl",
  "searchQuery": "warsaw",
  "segment": "office",
  "maxResults": 20,
  "fetchDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "country": "pl",
    "searchQuery": "warsaw",
    "segment": "office",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/officerentinfo-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 = {
    "country": "pl",
    "searchQuery": "warsaw",
    "segment": "office",
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/officerentinfo-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 '{
  "country": "pl",
  "searchQuery": "warsaw",
  "segment": "office",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/officerentinfo-scraper --silent --output-dataset

```

## MCP server setup

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