# Co-Star Real Estate Scraper (`solutionssmart/co-star-real-estate-scraper`) Actor

Scrapes publicly accessible pages from CoStar News GB and extracts article, property, and market signals when available.

- **URL**: https://apify.com/solutionssmart/co-star-real-estate-scraper.md
- **Developed by:** [Solutions Smart](https://apify.com/solutionssmart) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

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

### What does CoStar Real Estate Scraper do?

**CoStar Real Estate Scraper** extracts structured data from publicly available [CoStar News GB](https://www.costar.com/news/gb) articles. It is built for users who need UK commercial real estate news data focused on **transactions, developments, financings, sales, and lettings**.

This Actor does not scrape private CoStar subscriber listings or authenticated inventory. It works with public CoStar news pages and turns article content into a clean dataset that can be downloaded as JSON, CSV, Excel, XML, HTML, or accessed through the Apify API.

### Why scrape CoStar real estate news?

CoStar News GB publishes commercial property stories that can be useful for market monitoring, lead generation, investment research, and deal tracking. This CoStar scraper helps you collect those stories in a consistent format without manually opening every article.

Use this Actor to:

- Track UK office, retail, logistics, hotel, mixed-use, and development activity.
- Collect sale, acquisition, financing, refinancing, and letting stories.
- Monitor public news about developers, landlords, investors, occupiers, and agents.
- Build commercial real estate research datasets from public CoStar articles.
- Export results to BI tools, CRMs, spreadsheets, dashboards, or downstream enrichment pipelines.
- Schedule recurring runs on Apify and receive fresh CoStar real estate data automatically.

### What CoStar data can this Actor extract?

The exact fields depend on what CoStar exposes publicly in each article. Some articles include a property address and price, while others only expose a company, project, or transaction summary.

| Field | Description |
| --- | --- |
| `propertyId` | CoStar article or derived property identifier |
| `url` | Public CoStar article URL |
| `listingType` | Classified story type: `buy`, `rent`, `sold`, or `project` |
| `propertyType` | Property type when detected, such as office, retail, logistics, hotel, or data centre |
| `address` | Parsed address object when a public address is available |
| `price` | Publicly mentioned transaction, loan, or investment value |
| `headline` | CoStar article headline |
| `description` | Short public article description |
| `propertyFeatures` | Extracted property and article features, such as square footage or property category |
| `media` | Article image count and image URLs |
| `agent` / `agents` | Article author when available |
| `agency` | Main company or organization detected from article metadata/text |
| `isBuy`, `isRent`, `isSold`, `isProject` | Boolean classification flags |
| `dateUpdated` | Article published or modified date when available |
| `matchedSearchTerms` | Optional search term matches from your input |
| `scrapedAt` | Timestamp when the record was extracted |
| `scrapeStatus` | Extraction status |

### How to scrape CoStar News GB

1. Open the Actor on Apify.
2. Use the default start URL: `https://www.costar.com/news/gb`.
3. Set `maxItems` to the number of records you want.
4. Keep `strictStoryMode` enabled to focus on transaction, development, financing, and letting stories.
5. Keep `compactOutput` enabled for clean dataset rows.
6. Run the Actor.
7. Download your dataset from the **Dataset** tab or use the Apify API.

For recurring monitoring, schedule the Actor in Apify Console and export results through integrations, webhooks, or the API.

### Input options

Click the **Input** tab on the Actor page to configure the run. Common settings:

| Input | Default | Description |
| --- | --- | --- |
| `startUrls` | `https://www.costar.com/news/gb` | CoStar News GB section or article URLs to seed the crawl |
| `maxItems` | `50` | Maximum dataset records to store |
| `maxRequestsPerCrawl` | `200` | Request budget for listing pages and article pages |
| `maxPaginationPages` | `20` | Number of CoStar listing/category pages to follow |
| `compactOutput` | `true` | Removes null, empty, and static compatibility fields |
| `strictStoryMode` | `true` | Keeps transaction/development/financing/letting stories and drops people moves or commentary |
| `onlyPropertyArticles` | `true` | Skips generic non-property articles |
| `onlyUkArticles` | `true` | Focuses on UK-related articles in the GB feed |
| `requireAddress` | `false` | Skips records without a public address when enabled |
| `includeArticleBody` | `true` | Includes cleaned article body internally for extraction and matching |
| `includeHtml` | `false` | Stores raw HTML when enabled; increases dataset size |
| `includeFailedRecords` | `false` | Stores blocked/failed requests when enabled |
| `searchTerms` | `[]` | Adds `matchedSearchTerms` to records that mention your keywords |
| `proxyConfiguration` | disabled | Optional Apify Proxy configuration |
| `proxyInitializationTimeoutSecs` | `30` | Maximum time to wait for proxy setup |
| `fallbackToNoProxyOnProxyError` | `true` | Continue without proxy if proxy setup fails or times out |

#### Example input

```json
{
  "startUrls": [{ "url": "https://www.costar.com/news/gb" }],
  "maxItems": 50,
  "maxRequestsPerCrawl": 200,
  "maxPaginationPages": 20,
  "compactOutput": true,
  "strictStoryMode": true,
  "onlyPropertyArticles": true,
  "onlyUkArticles": true,
  "requireAddress": false,
  "includeFailedRecords": false,
  "searchTerms": ["office", "retail", "industrial", "London"]
}
````

### Output example

You can download the dataset extracted by this Actor in JSON, CSV, Excel, XML, HTML, or RSS format. A compact output item looks like this:

```json
{
  "propertyId": "1864242100",
  "url": "https://www.costar.com/article/1864242100/eastway-estates-buys-11-million-south-kensington-mixed-use-parade",
  "listingType": "buy",
  "propertyType": "mixed-use",
  "address": {
    "street": "18 Bute St",
    "suburb": "London",
    "state": "LND",
    "full": "18 Bute St, London, LND"
  },
  "price": {
    "display": "GBP 11 million"
  },
  "description": "South Kensington mixed-use parade changes hands",
  "headline": "Eastway Estates buys GBP 11 million South Kensington mixed-use parade",
  "media": {
    "imageCount": 1,
    "images": ["https://costar.brightspotcdn.com/path/to/image.jpg"]
  },
  "agent": {
    "name": "CoStar News author",
    "role": "author"
  },
  "agency": {
    "name": "Eastway Estates"
  },
  "isBuy": true,
  "isRent": false,
  "isSold": false,
  "isProject": false,
  "dateUpdated": "2026-06-05T12:00:00.000Z",
  "scrapedAt": "2026-06-05T21:00:00.000Z",
  "source": "CoStar News GB",
  "scrapeStatus": "ok",
  "matchedSearchTerms": ["London"]
}
```

### CoStar scraper filtering and deduplication

This Actor is designed to produce a clean dataset rather than a raw dump of every news article.

It filters out:

- People moves and hiring stories.
- General commentary and market opinion articles.
- Non-UK articles in the GB feed.
- Generic articles without property, transaction, or development signals.
- Duplicate records by article ID, canonical URL, and content fingerprint.

The Actor writes a `RUN-SUMMARY` record to the default key-value store with counters for discovered, queued, skipped, pushed, blocked, failed, duplicate-suppressed, and content-duplicate-suppressed records. This makes it easier to understand why the number of processed requests is higher than the number of dataset rows.

### How much does it cost to scrape CoStar News GB?

A default run with `maxItems=50` has recently cost about **$0.06 in Apify platform usage without proxy**. Actual cost can change depending on website response speed, max item count, retry rate, and whether you enable proxy.

Approximate default-run cost observed:

- Compute: about `$0.043`
- Request queue operations: about `$0.017`
- Key-value store writes: about `$0.001`
- Proxy: `$0.000` when disabled

Residential proxy can increase cost. Keep proxy disabled unless you see blocked requests or need it for your environment.

### Proxy and blocking

The Actor works without proxy in recent test runs. Apify Proxy is optional.

Use proxy only when:

- CoStar blocks requests in your Apify run.
- You see blocked pages or anti-bot responses.
- Your run fails before articles are processed.

If you enable Apify Proxy from the input UI, the Actor supports the Apify Console proxy shape and normalizes `apifyProxyGroups` to the SDK `groups` option internally. For residential proxy, use:

```json
{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

Make sure your Apify account has access to the selected proxy group.

If proxy initialization fails or times out, the Actor falls back to direct connection by default and records the proxy state in `RUN-SUMMARY`. Set `fallbackToNoProxyOnProxyError=false` if you want the run to fail instead whenever proxy cannot be initialized.

### Tips for better CoStar real estate data

- Keep `strictStoryMode=true` for transaction and development datasets.
- Keep `compactOutput=true` unless you need the full compatibility schema.
- Use `searchTerms` to tag relevant locations, companies, or property types.
- Leave `requireAddress=false` for better coverage, because valid finance and development stories may not expose a public address.
- Set `requireAddress=true` only when every output record must include an address.
- Increase `maxRequestsPerCrawl` and `maxPaginationPages` if you increase `maxItems`.
- Use scheduling for recurring market monitoring.

### Limitations

- This Actor scrapes public CoStar News GB pages only.
- It does not access private CoStar subscriber content.
- It does not scrape authenticated CoStar listing inventory.
- Some fields are inferred from article text because public news pages do not expose a stable property listing schema.
- Some valid transaction, finance, and development stories do not include a public property address.
- Output quality depends on what is available on the public article page at run time.

### Is it legal to scrape CoStar News GB?

This Actor extracts publicly available web data from public news pages. You should still make sure your use case complies with applicable laws, CoStar's terms, and data protection rules. If your results contain personal data, process it only when you have a lawful basis and follow relevant regulations such as GDPR.

### FAQ

#### Does this Actor scrape private CoStar listings?

No. It only extracts data from publicly accessible CoStar News GB pages.

#### Why are some addresses missing?

Some public CoStar articles are about financing, funds, portfolios, companies, or developments where no precise public address is exposed. Keep `requireAddress=false` for broader coverage, or set it to `true` to keep only rows with an extracted address.

#### Why does the Actor process more requests than the number of output rows?

The Actor crawls listing pages, article pages, category pages, and then filters out irrelevant or non-UK articles. The `RUN-SUMMARY` key-value-store record explains the full funnel.

#### Can I export CoStar data to CSV or Excel?

Yes. Apify datasets can be downloaded as JSON, CSV, Excel, XML, HTML, RSS, or accessed through the Apify API.

#### Should I use residential proxy?

Not by default. Use proxy only if your run is blocked. Proxy increases cost and is unnecessary when no blocking occurs.

#### Can this Actor monitor new CoStar property news automatically?

Yes. Use Apify schedules to run it daily, hourly, or on another interval, then connect the dataset to webhooks, integrations, or the Apify API.

### Support

If the Actor returns unexpected results, check:

1. The `RUN-SUMMARY` record in the key-value store.
2. Whether `strictStoryMode`, `onlyUkArticles`, or `requireAddress` filtered out records.
3. Whether CoStar changed its public page structure.
4. Whether proxy is needed for your run environment.

For bugs, feature requests, or custom extraction needs, use the Actor issue/support channel on Apify.

# Actor input Schema

## `startUrls` (type: `array`):

Public CoStar listing or section pages to seed the crawl.

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

Maximum number of records to store in the dataset.

## `maxRequestsPerCrawl` (type: `integer`):

Requested cap for total requests, including listing and detail pages. In filtered modes the actor may raise the effective cap so maxItems can be reached.

## `maxConcurrency` (type: `integer`):

Maximum number of pages processed in parallel.

## `desiredConcurrency` (type: `integer`):

Preferred steady-state parallelism target for the crawler.

## `maxPaginationPages` (type: `integer`):

Requested number of listing pages to follow from seeded sections. In filtered modes the actor may raise the effective value so enough strict records can be found.

## `includeArticleBody` (type: `boolean`):

Store the full cleaned article text when available.

## `includeHtml` (type: `boolean`):

Include raw article HTML in the dataset. This increases output size.

## `compactOutput` (type: `boolean`):

Remove null, empty, and static compatibility placeholder fields from dataset items. Disable only if you need the full compatibility schema.

## `onlyPropertyArticles` (type: `boolean`):

Skip generic newsroom articles that do not contain property-specific signals such as addresses, companies, prices, areas, or property types.

## `onlyUkArticles` (type: `boolean`):

Skip non-UK or globally focused articles when running against the CoStar GB news feed.

## `strictStoryMode` (type: `boolean`):

Keep only transaction, development, financing, sale, and letting stories. Drop people-moves, commentary, and broader market-analysis articles.

## `requireAddress` (type: `boolean`):

Skip otherwise valid records when no property address is exposed in the public article metadata.

## `includeFailedRecords` (type: `boolean`):

Store blocked or failed requests in the dataset. Disabled by default so output contains only successfully extracted records.

## `searchTerms` (type: `array`):

Optional terms used to add matchedSearchTerms to records that mention specific markets, tenants, or property types.

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

Optional Apify proxy configuration. Recommended if CoStar blocks your requests.

## `proxyInitializationTimeoutSecs` (type: `integer`):

Maximum seconds to wait while initializing proxy access before failing or falling back to direct connection.

## `fallbackToNoProxyOnProxyError` (type: `boolean`):

If enabled, the Actor continues without proxy when proxy initialization fails or times out. Disable this when proxy usage is mandatory.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.costar.com/news/gb"
    }
  ],
  "maxItems": 50,
  "maxRequestsPerCrawl": 200,
  "maxConcurrency": 3,
  "desiredConcurrency": 2,
  "maxPaginationPages": 20,
  "includeArticleBody": true,
  "includeHtml": false,
  "compactOutput": true,
  "onlyPropertyArticles": true,
  "onlyUkArticles": true,
  "strictStoryMode": true,
  "requireAddress": false,
  "includeFailedRecords": false,
  "searchTerms": [],
  "proxyInitializationTimeoutSecs": 30,
  "fallbackToNoProxyOnProxyError": true
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `input` (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 = {
    "startUrls": [
        {
            "url": "https://www.costar.com/news/gb"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("solutionssmart/co-star-real-estate-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 = { "startUrls": [{ "url": "https://www.costar.com/news/gb" }] }

# Run the Actor and wait for it to finish
run = client.actor("solutionssmart/co-star-real-estate-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 '{
  "startUrls": [
    {
      "url": "https://www.costar.com/news/gb"
    }
  ]
}' |
apify call solutionssmart/co-star-real-estate-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Co-Star Real Estate Scraper",
        "description": "Scrapes publicly accessible pages from CoStar News GB and extracts article, property, and market signals when available.",
        "version": "0.1",
        "x-build-id": "8rz5uKmpX41vzFvbm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solutionssmart~co-star-real-estate-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solutionssmart-co-star-real-estate-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/solutionssmart~co-star-real-estate-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solutionssmart-co-star-real-estate-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/solutionssmart~co-star-real-estate-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solutionssmart-co-star-real-estate-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Public CoStar listing or section pages to seed the crawl.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max output items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of records to store in the dataset.",
                        "default": 50
                    },
                    "maxRequestsPerCrawl": {
                        "title": "Max requests per crawl",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Requested cap for total requests, including listing and detail pages. In filtered modes the actor may raise the effective cap so maxItems can be reached.",
                        "default": 200
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of pages processed in parallel.",
                        "default": 3
                    },
                    "desiredConcurrency": {
                        "title": "Desired concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Preferred steady-state parallelism target for the crawler.",
                        "default": 2
                    },
                    "maxPaginationPages": {
                        "title": "Max pagination pages",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Requested number of listing pages to follow from seeded sections. In filtered modes the actor may raise the effective value so enough strict records can be found.",
                        "default": 20
                    },
                    "includeArticleBody": {
                        "title": "Include article body",
                        "type": "boolean",
                        "description": "Store the full cleaned article text when available.",
                        "default": true
                    },
                    "includeHtml": {
                        "title": "Include raw HTML",
                        "type": "boolean",
                        "description": "Include raw article HTML in the dataset. This increases output size.",
                        "default": false
                    },
                    "compactOutput": {
                        "title": "Compact output",
                        "type": "boolean",
                        "description": "Remove null, empty, and static compatibility placeholder fields from dataset items. Disable only if you need the full compatibility schema.",
                        "default": true
                    },
                    "onlyPropertyArticles": {
                        "title": "Only property articles",
                        "type": "boolean",
                        "description": "Skip generic newsroom articles that do not contain property-specific signals such as addresses, companies, prices, areas, or property types.",
                        "default": true
                    },
                    "onlyUkArticles": {
                        "title": "Only UK articles",
                        "type": "boolean",
                        "description": "Skip non-UK or globally focused articles when running against the CoStar GB news feed.",
                        "default": true
                    },
                    "strictStoryMode": {
                        "title": "Strict story mode",
                        "type": "boolean",
                        "description": "Keep only transaction, development, financing, sale, and letting stories. Drop people-moves, commentary, and broader market-analysis articles.",
                        "default": true
                    },
                    "requireAddress": {
                        "title": "Require address",
                        "type": "boolean",
                        "description": "Skip otherwise valid records when no property address is exposed in the public article metadata.",
                        "default": false
                    },
                    "includeFailedRecords": {
                        "title": "Include failed records",
                        "type": "boolean",
                        "description": "Store blocked or failed requests in the dataset. Disabled by default so output contains only successfully extracted records.",
                        "default": false
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Optional terms used to add matchedSearchTerms to records that mention specific markets, tenants, or property types.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy configuration. Recommended if CoStar blocks your requests."
                    },
                    "proxyInitializationTimeoutSecs": {
                        "title": "Proxy initialization timeout",
                        "minimum": 5,
                        "type": "integer",
                        "description": "Maximum seconds to wait while initializing proxy access before failing or falling back to direct connection.",
                        "default": 30
                    },
                    "fallbackToNoProxyOnProxyError": {
                        "title": "Fallback to direct connection on proxy error",
                        "type": "boolean",
                        "description": "If enabled, the Actor continues without proxy when proxy initialization fails or times out. Disable this when proxy usage is mandatory.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
