# SpareRoom Scraper (`solidcode/spareroom-scraper`) Actor

\[💰 $0.85 / 1K] Extract UK & US flatshare listings from SpareRoom — rent, availability, room & property details, location, amenities, advertiser info, and photos. Covers rooms for rent, room-wanted, and buddy-up ads. Search by location and filters, or paste a SpareRoom search or listing URL.

- **URL**: https://apify.com/solidcode/spareroom-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (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 $0.85 / 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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## SpareRoom Scraper

Pull flatshare and room-rental listings from SpareRoom across the UK and US — rent and deposit, move-in dates, room and property details, neighbourhood and map coordinates, amenities, advertiser profiles, and full photo galleries. Covers all three SpareRoom ad types: rooms for rent, room-wanted, and buddy-up. Built for renters, relocation teams, lettings agents, and property-market researchers who need structured SpareRoom data without copy-pasting listings one ad at a time.

### Why This Scraper?

- **All three SpareRoom ad types** — rooms for rent (offered), room-wanted, and buddy-up, each with the right fields: property attributes for landlords' ads, seeker attributes for people-looking ads.
- **Dual UK + US coverage in one actor** — spareroom.co.uk and spareroom.com from a single run, with prices returned in the listing's own currency (GBP or USD) and a region selector for ambiguous locations.
- **Just paste a postcode, ZIP, or city** — start from a plain location like `E1`, `SW1`, `90210`, or `Los Angeles`; no need to hand-build a search URL. Full SpareRoom search and listing URLs are accepted too.
- **Five room-type filters** — single, double, en-suite, studio, and whole-property, applied at the source so you only pay for the rooms you want.
- **Rent banding and move-in date filters** — set a minimum and maximum monthly rent (pcm) and an "available from" date to narrow to rooms that fit a real tenancy window.
- **Full per-listing detail by default** — every row comes with the complete description, deposit, amenities, move-in date, and tenant preferences, not just the search-card summary. No toggle to flip.
- **Map-ready geocoordinates on every listing** — exact latitude and longitude, plus neighbourhood, postcode/ZIP, and nearest-station walk times for mapping and commute analysis.
- **Full photo galleries on demand** — flip one switch to pull every gallery image per listing instead of just the cover photo.
- **Advertiser and seeker intelligence** — advertiser name, type (private / agent / live-in landlord) and verified badge on offered ads; gender-and-occupation seeker profiles and rooms-sought counts on room-wanted and buddy-up ads.
- **Tenancy preference details** — couples-OK, pets, smoking, DSS/benefits accepted, minimum term, and age preferences captured straight from each listing.

### Use Cases

**Renter & Flatmate Search**
- Sweep every room in a postcode area or city under your monthly budget
- Filter to en-suite or studio rooms available from your move-in date
- Build a shortlist of verified advertisers before sending a single enquiry
- Compare cover photos and rent across neighbourhoods at a glance

**Relocation Research**
- Map available rooms by latitude/longitude around a new office or campus
- Compare typical rents across UK postcode areas or US cities before a move
- Surface rooms with short nearest-station walk times for an easy commute
- Pull US and UK markets side by side for cross-border relocation

**Lettings & Property Market Research**
- Track room supply and asking rents by area over time
- Benchmark rents by room type — single vs double vs en-suite vs studio
- Measure agent vs private-landlord share of listings in a market
- Monitor deposit levels and bills-included offers across a city

**Lead Generation**
- Build advertiser contact lists from offered ads in target areas
- Identify room-wanted and buddy-up seekers for matchmaking services
- Find live-in landlords and lettings agents actively posting rooms
- Spot newly posted and featured listings the moment they appear

**Price & Demand Analysis**
- Analyse rent distribution per area, room type, and rental period
- Compare advertised rents against deposit and bills-included terms
- Track how move-in dates cluster across a season
- Feed pricing dashboards with fresh per-listing rent data

### Getting Started

#### Search by Location

The simplest run — a single UK postcode area, default filters:

```json
{
    "searchUrls": ["E1"]
}
````

#### Filtered Search

A budget-bounded search for double or en-suite rooms with a move-in date:

```json
{
    "searchUrls": ["SW1"],
    "adType": "offered",
    "roomTypes": ["double", "ensuite"],
    "rentMin": 800,
    "rentMax": 1500,
    "availableFrom": "2026-09-01",
    "maxResults": 200
}
```

#### Full Galleries, US Region, and Pasted URLs

A US search with full photo galleries plus a pasted SpareRoom listing URL:

```json
{
    "searchUrls": [
        "Los Angeles",
        "https://www.spareroom.com/flatshare/flatshare_detail.pl?flatshare_id=18234567"
    ],
    "region": "us",
    "includePhotos": true,
    "maxResults": 100
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchUrls` | string\[] | `["E1"]` | SpareRoom search-result URLs, individual listing URLs, or plain locations. A location can be a UK postcode area (`E1`, `SW1`) or a US city or ZIP (`Los Angeles`, `90210`). Full URLs take priority and ignore the filter fields below. |
| `region` | select | `Auto-detect` | Which SpareRoom site to use for a plain location: Auto-detect, United Kingdom, or United States. Ignored for full URLs. |

#### Build a Search

These filters apply when you provide a plain location. They are ignored when you paste full SpareRoom URLs.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `adType` | select | `Rooms for rent (offered)` | Which kind of ad to collect: Rooms for rent (offered), Room wanted, or Buddy up. |
| `roomTypes` | multi-select | `[]` (all) | Limit to these room types: Single, Double, En-suite, Studio, or Whole property. Leave empty for all types. |

#### Price & Availability

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `rentMin` | integer | — | Only include listings with monthly rent at or above this amount. |
| `rentMax` | integer | — | Only include listings with monthly rent at or below this amount. |
| `availableFrom` | string | — | Only include rooms available on or after this date, formatted `YYYY-MM-DD` (e.g. `2026-09-01`). |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum listings to collect per URL or search. Set to `0` for unlimited. Results arrive in pages and the last page is always returned in full, so you may receive a few more than this number. |
| `includePhotos` | boolean | `false` | When on, collects the complete photo gallery for each listing. When off, you still get the cover photo and all other detail fields — only the extra gallery images are skipped. |

### Output

Every listing is one flat row, with the full per-listing detail — description, latitude/longitude, amenities, deposit, advertiser profile, move-in date, and tenant preferences — populated by default on every result. Turn on `includePhotos` to also include the complete photo gallery. The two ad types return materially different shapes — examples for each follow.

#### Rooms for Rent (offered)

```json
{
    "id": "18234567",
    "url": "https://www.spareroom.co.uk/flatshare/flatshare_detail.pl?flatshare_id=18234567",
    "adType": "offered",
    "title": "Bright double room in Shoreditch flatshare",
    "description": "Spacious double room in a friendly 3-bed flat, two minutes from the station...",
    "status": "active",
    "isNew": true,
    "isFeatured": false,
    "rent": 1100,
    "rentPeriod": "per month",
    "currency": "GBP",
    "billsIncluded": true,
    "deposit": 1100,
    "availableFrom": "2026-09-01",
    "minTerm": "6 months",
    "propertyType": "Flat",
    "roomsInProperty": 3,
    "occupants": 2,
    "furnishings": "Furnished",
    "area": "Shoreditch",
    "postcode": "E1",
    "latitude": 51.5246,
    "longitude": -0.0786,
    "nearestStation": { "name": "Shoreditch High Street", "minutes": 3, "mode": "walk" },
    "amenities": { "Broadband": "Yes", "Living room": "Yes", "Parking": "No" },
    "couplesAllowed": false,
    "petsAllowed": false,
    "smokingAllowed": false,
    "genderPreference": "No preference",
    "advertiserName": "Sarah",
    "advertiserType": "Live-in landlord",
    "advertiserVerified": true,
    "coverImage": "https://photos.spareroom.co.uk/.../large/image1.jpg",
    "photoCount": 8,
    "photos": [{ "url": "https://photos.spareroom.co.uk/.../large/image1.jpg", "caption": null }],
    "scrapedAt": "2026-06-13T09:30:00Z"
}
```

#### Room Wanted / Buddy Up (seeker)

```json
{
    "id": "9912345",
    "url": "https://www.spareroom.co.uk/flatmate/flatmate_detail.pl?flatshare_id=9912345",
    "adType": "wanted",
    "title": "Young professional looking for a double room in East London",
    "rent": 900,
    "rentPeriod": "per month",
    "currency": "GBP",
    "area": "East London",
    "roomsSought": "Double",
    "roomsSoughtCount": 1,
    "seekerProfile": "Female, professional",
    "advertiserVerified": true,
    "coverImage": "https://photos.spareroom.co.uk/.../large/image1.jpg",
    "photoCount": 1,
    "scrapedAt": "2026-06-13T09:30:00Z"
}
```

#### Core Fields (all listings)

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | SpareRoom advert ID |
| `url` | string | Canonical listing URL |
| `adType` | string | `offered`, `wanted`, or `buddyup` |
| `title` | string | Ad title |
| `description` | string | Full ad text (detailed listings) |
| `status` | string | Listing status |
| `isNew` | boolean | Newly posted flag |
| `isFeatured` | boolean | Promoted / bold ad flag |
| `rent` | number | Rent amount in the listing's currency |
| `rentPeriod` | string | `per month` or `per week` |
| `currency` | string | `GBP` or `USD` |
| `scrapedAt` | string | ISO timestamp of data extraction |

#### Pricing & Terms (offered)

| Field | Type | Description |
|-------|------|-------------|
| `billsIncluded` | boolean | Whether bills are included in the rent |
| `deposit` | number | Security deposit when listed |
| `availableFrom` | string | Move-in date (ISO `YYYY-MM-DD`) |
| `minTerm` | string | Minimum tenancy term |
| `rooms` | object\[] | Per-room breakdown for multi-room ads (price, period, en-suite, currency) |

#### Property & Location (offered)

| Field | Type | Description |
|-------|------|-------------|
| `propertyType` | string | Flat, house, etc. |
| `roomsInProperty` | integer | Total rooms in the property |
| `occupants` | integer | Current occupant count |
| `furnishings` | string | Furnished / unfurnished |
| `area` | string | Neighbourhood or area name |
| `postcode` | string | Postcode (UK) or ZIP (US) |
| `latitude` | number | Latitude (detailed listings) |
| `longitude` | number | Longitude (detailed listings) |
| `nearestStation` | object | `{ name, minutes, mode }` walk/transit to nearest station |
| `amenities` | object | Map of amenity flags (broadband, parking, living room, etc.) |

#### Tenant Preferences (offered)

| Field | Type | Description |
|-------|------|-------------|
| `couplesAllowed` | boolean | Couples accepted |
| `petsAllowed` | boolean | Pets accepted |
| `smokingAllowed` | boolean | Smoking accepted |
| `dssAllowed` | boolean | DSS / benefits accepted (UK) |
| `genderPreference` | string | Preferred tenant gender |
| `minAge` / `maxAge` | integer | Age preference bounds |

#### Advertiser & Photos

| Field | Type | Description |
|-------|------|-------------|
| `advertiserName` | string | Advertiser display name |
| `advertiserType` | string | private / agent / live-in landlord |
| `advertiserVerified` | boolean | Verified advertiser badge |
| `coverImage` | string | URL of the main listing photo |
| `photoCount` | integer | Number of photos on the listing |
| `photos` | object\[] | Photo gallery: `{ url, caption }` (cover only unless `includePhotos` is on) |

#### Seeker Fields (wanted / buddy up)

| Field | Type | Description |
|-------|------|-------------|
| `area` | string | Example matching area the seeker is targeting |
| `roomsSought` | string | Type of room being sought |
| `roomsSoughtCount` | integer | Number of rooms being sought |
| `seekerProfile` | string | Seeker gender and occupation |

### Tips for Best Results

- **Start with a small `maxResults`** — run 25–50 first to confirm the area and filters return what you expect, then scale up.
- **Full detail comes by default** — description, deposit, amenities, exact latitude/longitude, advertiser, and tenant preferences are on every row. Turn on `includePhotos` only if you also need the complete photo gallery for each listing.
- **Use a plain postcode area, not a wide region** — `E1` or `SW1` scopes tightly to that area; a vague term returns a broader, less relevant set.
- **Set the region explicitly for US ZIPs and city names** — choose United States so a numeric ZIP or a US city name resolves to spareroom.com rather than being read as UK.
- **Match `adType` to your goal** — use offered for room supply and rents, wanted and buddy-up for demand-side and matchmaking research.
- **Mix locations and URLs in one run** — combine several postcode areas, cities, and pasted listing URLs in a single `searchUrls` list to gather everything at once.
- **Filter rent at the source** — set `rentMin`/`rentMax` rather than collecting everything and filtering later, so every result already fits your budget band.

### Pricing

**From $0.85 per 1,000 results** — undercuts the typical SpareRoom data tool while covering both UK and US in one run. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.10 | $0.095 | $0.09 | $0.085 |
| 1,000 | $1.00 | $0.95 | $0.90 | $0.85 |
| 10,000 | $10.00 | $9.50 | $9.00 | $8.50 |
| 100,000 | $100.00 | $95.00 | $90.00 | $85.00 |

A "result" is one listing row in your output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate room-rental research, relocation planning, and market analysis. You are responsible for complying with applicable laws and SpareRoom's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data (such as advertiser names) responsibly and in line with privacy regulations. </content> </invoke>

# Actor input Schema

## `searchUrls` (type: `array`):

Paste one or more SpareRoom search-result URLs, individual listing URLs, or plain locations. A location can be a UK postcode area like "E1" or "SW1", or a US city or ZIP like "Los Angeles" or "90210". To get a search URL, set your filters on spareroom.co.uk (or spareroom.com) and copy the URL from the address bar. When you provide full URLs, the filter fields below are ignored.

## `region` (type: `string`):

Which SpareRoom site to use when you enter a plain location (not a full URL). Auto-detect guesses from the text (postcode area = UK, city/ZIP = US). Ignored for full URLs.

## `adType` (type: `string`):

Which kind of ad to collect. 'Rooms for rent' are rooms offered by a landlord or current tenant; 'Room wanted' are people looking for a room; 'Buddy up' are people looking to find a place together.

## `roomTypes` (type: `array`):

Only include rooms of these types. Leave empty for all room types.

## `rentMin` (type: `integer`):

Only include listings with rent at or above this amount (in the listing's own currency and rental period, e.g. per month). Leave empty for no lower bound.

## `rentMax` (type: `integer`):

Only include listings with rent at or below this amount. Leave empty for no upper bound.

## `availableFrom` (type: `string`):

Only include rooms available on or after this date. Use the format YYYY-MM-DD, e.g. 2026-09-01. Leave empty for any move-in date.

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

Maximum number of listings to collect per URL or search. Set to 0 for unlimited (every listing the search returns). Results come in pages and the last page is always returned in full, so you may receive a few more than this number.

## `includePhotos` (type: `boolean`):

Every listing already comes with its full details (description, deposit, amenities, map coordinates, advertiser, and tenant preferences). Turn this on to also collect the complete photo gallery for each listing — every image, not just the cover photo. Galleries are large, so leave this off unless you need all the photos.

## Actor input object example

```json
{
  "searchUrls": [
    "E1"
  ],
  "region": "auto",
  "adType": "offered",
  "roomTypes": [],
  "maxResults": 100,
  "includePhotos": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of listings with rent, room type, location, and availability.

## `property` (type: `string`):

Property type, rooms, occupants, furnishings, and amenities for each listing.

## `advertiser` (type: `string`):

Advertiser details and location for each listing.

# 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 = {
    "searchUrls": [
        "E1"
    ],
    "region": "auto",
    "adType": "offered",
    "roomTypes": [],
    "availableFrom": "",
    "maxResults": 100,
    "includePhotos": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/spareroom-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 = {
    "searchUrls": ["E1"],
    "region": "auto",
    "adType": "offered",
    "roomTypes": [],
    "availableFrom": "",
    "maxResults": 100,
    "includePhotos": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/spareroom-scraper").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 '{
  "searchUrls": [
    "E1"
  ],
  "region": "auto",
  "adType": "offered",
  "roomTypes": [],
  "availableFrom": "",
  "maxResults": 100,
  "includePhotos": false
}' |
apify call solidcode/spareroom-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SpareRoom Scraper",
        "description": "[💰 $0.85 / 1K] Extract UK & US flatshare listings from SpareRoom — rent, availability, room & property details, location, amenities, advertiser info, and photos. Covers rooms for rent, room-wanted, and buddy-up ads. Search by location and filters, or paste a SpareRoom search or listing URL.",
        "version": "1.0",
        "x-build-id": "rN7Qrcgwu9vDwaWEG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~spareroom-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-spareroom-scraper",
                "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/solidcode~spareroom-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-spareroom-scraper",
                "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/solidcode~spareroom-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-spareroom-scraper",
                "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",
                "properties": {
                    "searchUrls": {
                        "title": "SpareRoom URLs or locations",
                        "type": "array",
                        "description": "Paste one or more SpareRoom search-result URLs, individual listing URLs, or plain locations. A location can be a UK postcode area like \"E1\" or \"SW1\", or a US city or ZIP like \"Los Angeles\" or \"90210\". To get a search URL, set your filters on spareroom.co.uk (or spareroom.com) and copy the URL from the address bar. When you provide full URLs, the filter fields below are ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "auto",
                            "uk",
                            "us"
                        ],
                        "type": "string",
                        "description": "Which SpareRoom site to use when you enter a plain location (not a full URL). Auto-detect guesses from the text (postcode area = UK, city/ZIP = US). Ignored for full URLs.",
                        "default": "auto"
                    },
                    "adType": {
                        "title": "Listing type",
                        "enum": [
                            "offered",
                            "wanted",
                            "buddyup"
                        ],
                        "type": "string",
                        "description": "Which kind of ad to collect. 'Rooms for rent' are rooms offered by a landlord or current tenant; 'Room wanted' are people looking for a room; 'Buddy up' are people looking to find a place together.",
                        "default": "offered"
                    },
                    "roomTypes": {
                        "title": "Room type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include rooms of these types. Leave empty for all room types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "single",
                                "double",
                                "ensuite",
                                "studio",
                                "wholeProperty"
                            ],
                            "enumTitles": [
                                "Single room",
                                "Double room",
                                "En-suite room",
                                "Studio",
                                "Whole property"
                            ]
                        }
                    },
                    "rentMin": {
                        "title": "Minimum rent",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Only include listings with rent at or above this amount (in the listing's own currency and rental period, e.g. per month). Leave empty for no lower bound."
                    },
                    "rentMax": {
                        "title": "Maximum rent",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Only include listings with rent at or below this amount. Leave empty for no upper bound."
                    },
                    "availableFrom": {
                        "title": "Available from",
                        "type": "string",
                        "description": "Only include rooms available on or after this date. Use the format YYYY-MM-DD, e.g. 2026-09-01. Leave empty for any move-in date."
                    },
                    "maxResults": {
                        "title": "Max results per search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to collect per URL or search. Set to 0 for unlimited (every listing the search returns). Results come in pages and the last page is always returned in full, so you may receive a few more than this number.",
                        "default": 100
                    },
                    "includePhotos": {
                        "title": "Include the full photo gallery",
                        "type": "boolean",
                        "description": "Every listing already comes with its full details (description, deposit, amenities, map coordinates, advertiser, and tenant preferences). Turn this on to also collect the complete photo gallery for each listing — every image, not just the cover photo. Galleries are large, so leave this off unless you need all the photos.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```