# Redfin Real Estate Agents Scraper (`automation-lab/redfin-real-estate-agents-scraper`) Actor

Extract live Redfin agent leads from market directories or profiles: emails, phones, ratings, reviews, brokerage, service regions, and transaction performance. Export to JSON, CSV, Excel, API, or webhooks.

- **URL**: https://apify.com/automation-lab/redfin-real-estate-agents-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 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.

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

Extract **Redfin real estate agent leads** from public market directories and profiles.
Get names, emails, phone numbers, ratings, reviews, service regions, brokerage details,
and recent and lifetime transaction performance in one structured dataset.

Use the prefilled Seattle directory to try the scraper in minutes.
No Redfin login or private API key is required.

### What does Redfin Real Estate Agents Scraper do?

Redfin Real Estate Agents Scraper converts public
[Redfin](https://www.redfin.com/) agent pages into clean agent records.
It supports two practical source types:

- 🏙️ **Market directories** for city, neighborhood, ZIP code, or county coverage
- 👤 **Direct agent profiles** for one-agent research and CRM enrichment

The Actor uses a lightweight HTTP workflow instead of launching a browser.
It extracts live source data, deduplicates agents by Redfin agent ID,
applies optional quality filters, and exports the result through Apify.

### Who is Redfin Real Estate Agents Scraper for?

**Brokerage recruiters**

- Build city-specific recruiting lists with direct contact details.
- Prioritize established agents by ratings, reviews, and deal volume.
- Refresh lists on a schedule instead of buying an aging spreadsheet.

**Real estate software and marketing vendors**

- Find agents in markets served by your CRM, advertising, or transaction product.
- Segment outreach by service region, brokerage, and production history.
- Send new records into a lead-routing or enrichment workflow.

**Lenders, title companies, and service providers**

- Identify active agents in a target lending territory.
- Compare agents by market, recent deals, and lifetime production.
- Monitor new or newly active professionals in recurring runs.

**Data and market intelligence teams**

- Build repeatable market coverage datasets.
- Compare agent presence across overlapping Redfin directories.
- Analyze publicly reported reputation and production signals.

### Why use this Redfin agent scraper?

- ✅ **Live public data** from the market or profile URL you provide
- 📧 **Contact fields** including public email and phone when available
- 📈 **Performance metrics** for recent deals and lifetime transactions
- ⭐ **Quality filters** for minimum rating and review count
- 🧹 **Deterministic deduplication** across overlapping sources
- ⚡ **HTTP-only runtime** with low memory and no browser overhead
- 📦 **Ready exports** in JSON, CSV, Excel, XML, and RSS
- 🔌 **API and webhook access** for automated lead pipelines
- 🗓️ **Schedules** for weekly or monthly market refreshes

### What Redfin agent data can you extract?

| Category | Fields |
|---|---|
| Identity | Agent ID, full name, first name, last name |
| Contact | Public email, phone, profile URL, photo URL |
| Professional | Job title, custom title, brokerage, license number, state |
| Coverage | Business market, service area, service regions, languages |
| Reputation | Redfin rating and review count |
| Production | Past-year deals, regional deals, lifetime transactions, lifetime volume |
| Status | Premier, active, serves buyers, serves sellers |
| Profile detail | Public biography on direct profile inputs |
| Provenance | Source URL, input type, scrape timestamp |

Some fields differ by source type.
Market directories are ideal for broad contact lists.
Direct profiles can add biography, license, and detailed region information.
Fields not published by Redfin are omitted rather than guessed.

### How much does it cost to scrape Redfin agents?

This Actor uses **pay-per-event** pricing.
You pay one small run-start fee and one event for each unique agent saved.
Apify compute, proxy, storage, and export access are included.

| Plan tier | Start | Per agent |
|---|---:|---:|
| Free | $0.005 | $0.0002477 |
| Starter / Bronze | $0.005 | $0.00021539 |
| Scale / Silver | $0.005 | $0.000168 |
| Business / Gold | $0.005 | $0.00012923 |

Example Bronze costs:

| Workflow | Agents | Estimated charge |
|---|---:|---:|
| Test one profile | 1 | about $0.00522 |
| Focused recruiting list | 100 | about $0.02654 |
| Multi-market refresh | 1,000 | about $0.22039 |

The Apify Free plan includes monthly platform credits,
so a small evaluation run can normally be completed with no separate subscription.
Final charges appear before and after each run in the Apify Console.

### How to scrape Redfin real estate agents

1. Open **Redfin Real Estate Agents Scraper** on Apify.
2. Add one or more Redfin market-directory or agent-profile URLs.
3. Set a low maximum agent count for your first run.
4. Optionally choose a minimum rating, minimum reviews, or active-only filter.
5. Click **Start** and wait for the dataset preview.
6. Review the fields and export JSON, CSV, Excel, XML, or RSS.
7. Save the configuration as a task if you want scheduled refreshes.

A basic city-directory input looks like this:

```json
{
  "startUrls": [
    {
      "url": "https://www.redfin.com/city/16163/WA/Seattle/real-estate/agents"
    }
  ],
  "maxItems": 25
}
````

A direct profile lookup looks like this:

```json
{
  "startUrls": [
    {
      "url": "https://www.redfin.com/real-estate-agents/aaron-freeman"
    }
  ],
  "maxItems": 1
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `startUrls` | array | Seattle directory prefill | Redfin directory and/or direct profile URLs |
| `maxItems` | integer | 25 | Maximum unique agents saved across all sources |
| `minimumRating` | number | not set | Keep agents at or above this 0–5 rating |
| `minimumReviews` | integer | not set | Keep agents with at least this many reviews |
| `onlyActive` | boolean | false | Keep agents currently marked active or taking calls |

Only `redfin.com` agent-directory and agent-profile URLs are accepted.
Property listing URLs are intentionally rejected so every output row follows one agent schema.

### Filter top-rated or active Redfin agents

Use filters to reduce manual lead qualification:

```json
{
  "startUrls": [
    {
      "url": "https://www.redfin.com/city/16163/WA/Seattle/real-estate/agents"
    }
  ],
  "maxItems": 100,
  "minimumRating": 4.8,
  "minimumReviews": 25,
  "onlyActive": true
}
```

Filters fail closed.
For example, when a minimum rating is set and Redfin does not publish a parseable rating,
that record is excluded instead of being assumed to qualify.

### Output example

Each dataset item represents one unique agent:

```json
{
  "agentId": 52400,
  "name": "Aaron Freeman",
  "firstName": "Aaron",
  "lastName": "Freeman",
  "email": "aaron.freeman@redfin.com",
  "phone": "(360) 587-0510",
  "profileUrl": "https://www.redfin.com/real-estate-agents/aaron-freeman",
  "jobTitle": "Redfin Principal Agent",
  "officeState": "WA",
  "businessMarket": "Seattle",
  "serviceRegions": ["Seattle", "West Seattle", "Bellevue"],
  "licenseNumber": "119619",
  "rating": 4.9,
  "reviews": 24,
  "pastYearDeals": 13,
  "lifetimeTransactions": 174,
  "lifetimeVolume": 132046750,
  "isPremier": true,
  "isActive": true,
  "sourceUrl": "https://www.redfin.com/real-estate-agents/aaron-freeman",
  "inputType": "agent-profile",
  "scrapedAt": "2026-07-18T04:00:00.000Z"
}
```

Numbers are returned as numbers, booleans as booleans,
and list fields such as service regions and languages as arrays.

### Market directory and profile behavior

**Market-directory mode** reads the live structured directory for a Redfin region.
It is the fastest way to collect many agents and normally provides contact,
market, brokerage, reputation, and production fields.

**Profile mode** reads public profile state in one page request.
It can add license number, biography, detailed selected regions,
review counts, and profile-level transaction statistics.

If both inputs contain the same agent,
only the first record is saved because the Actor deduplicates on `agentId`.
Put profile URLs first when profile-level fields are more important than broad coverage.

### Tips for best results

- 🧪 Start with `maxItems: 5` to inspect your target market cheaply.
- 🎯 Use one quality filter at a time before combining strict thresholds.
- 👤 Put direct profiles before market URLs when overlapping sources are used.
- 🏙️ Use Redfin's canonical directory URL copied from your browser.
- 🔁 Schedule repeat runs into a named dataset or downstream database.
- 🧹 Deduplicate historical snapshots by `agentId` and `scrapedAt` downstream.
- 📊 Treat performance figures as Redfin's public snapshot, not audited production.

### Export Redfin agent leads

The default dataset can be downloaded from the Apify Console as:

- JSON for APIs and data engineering
- CSV for spreadsheets and CRM imports
- Excel for recruiting operations
- XML or RSS for legacy integrations

You can select fields, rename columns downstream,
or read pages of dataset items through the Apify Dataset API.

### Integrations and automation workflows

**Redfin agents → Google Sheets**

Run a city task weekly and append new agent IDs to a recruiting sheet.
Use a lookup step to update ratings and recent production for existing rows.

**Redfin agents → HubSpot or Salesforce**

Map `name`, `email`, `phone`, `brokerageName`, and `businessMarket`
to lead or contact properties through Make, Zapier, or your own webhook.

**Redfin agents → Slack or Microsoft Teams**

Send an alert when a scheduled run finds agents meeting a high review threshold
or entering a watched market directory.

**Redfin agents → data warehouse**

Use a webhook after each run to ingest the dataset into BigQuery,
Snowflake, PostgreSQL, or an object-storage lake.

### Using the Apify API with Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/redfin-real-estate-agents-scraper').call({
  startUrls: [
    { url: 'https://www.redfin.com/city/16163/WA/Seattle/real-estate/agents' }
  ],
  maxItems: 25
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Using the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/redfin-real-estate-agents-scraper').call(run_input={
    'startUrls': [
        {'url': 'https://www.redfin.com/real-estate-agents/aaron-freeman'}
    ],
    'maxItems': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Using the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~redfin-real-estate-agents-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [
      {"url": "https://www.redfin.com/city/16163/WA/Seattle/real-estate/agents"}
    ],
    "maxItems": 25
  }'
```

Use the returned run object to read its `defaultDatasetId`,
then fetch items from `/v2/datasets/{datasetId}/items`.

### Use Redfin agent data with AI agents via MCP

This Actor can be used by AI assistants through the
[Apify Model Context Protocol integration](https://docs.apify.com/platform/integrations/mcp).

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/redfin-real-estate-agents-scraper"
```

For Claude Desktop, Cursor, or VS Code, add:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/redfin-real-estate-agents-scraper"
    }
  }
}
```

Example prompts:

- "Use automation-lab/redfin-real-estate-agents-scraper to find 25 Seattle Redfin agents."
- "Extract this Redfin agent profile and summarize production and service regions."
- "Build a list of active Redfin agents rated at least 4.8 with 25 reviews."

Your AI client authenticates to Apify and receives the structured dataset,
not an unstructured copy of the web page.

### Schedule recurring Redfin market monitoring

Save a tested input as an Apify Task.
Add a weekly or monthly schedule based on how often your workflow needs updates.
Use a webhook to notify the destination system after a successful run.

For historical analysis, keep `agentId` as the stable key
and `scrapedAt` as the observation timestamp.
This supports changes in rating, review count, contact details, and production metrics.

### Data quality and limitations

The Actor returns data that Redfin publishes on the supplied public pages.
Contact, brokerage, license, active status, and performance fields may not appear for every agent.
Missing optional values are omitted and never invented.

Redfin can change its page structure or anti-bot controls.
The Actor uses a US residential HTTP route, conservative sequential requests,
and bounded retries to reduce failures and unnecessary traffic.

A strict filter can legitimately produce zero saved agents.
That is different from a source extraction failure,
which causes a failed run when no supplied source can be read.

### Is it legal to scrape Redfin agent data?

Scraping publicly available information is generally permitted in many jurisdictions,
but how you collect and use personal or professional data can be regulated.
Use this Actor responsibly, respect applicable laws and Redfin's terms,
and do not use results for spam, harassment, discrimination, or unlawful profiling.

If you process personal data under GDPR, CCPA, or similar rules,
identify a lawful basis, minimize retention, secure the dataset,
and honor applicable access or deletion rights.
This documentation is not legal advice.

### FAQ

**How fast is the Redfin agents scraper?**

A focused directory run usually needs one HTTP source request plus dataset writes.
Direct profiles also use one page request each.
Runtime depends on source count, retries, and the selected item limit.

**How much does one Redfin agent record cost?**

The current Bronze price is $0.00021539 per saved agent plus a $0.005 run-start fee.
Higher Apify plan tiers receive volume discounts.

**Does it use a Redfin API key or login?**

No. It extracts data from public Redfin agent surfaces through Apify infrastructure.
You only need an Apify account to run the Actor.

**Why are some email, phone, or brokerage fields missing?**

Redfin does not publish every field for every agent or page type.
Try a direct profile URL for deeper profile fields,
but the Actor will not guess missing contact data.

**Why did my filtered run return no rows?**

Your thresholds may be stricter than the records in that market.
Remove `onlyActive`, lower `minimumReviews`, or remove `minimumRating`,
then inspect a small unfiltered sample.

**Why was my URL rejected?**

Only canonical Redfin agent-directory and direct agent-profile paths are supported.
Property listing, home search, and non-Redfin URLs are rejected by design.

**Can I combine several market directories?**

Yes. Add several URLs to `startUrls`.
The global `maxItems` limit and agent-ID deduplication apply across all of them.

**How does this compare with a static agent database?**

This Actor reads the supplied live public Redfin market or profile surface.
A static database may be faster for nationwide bulk access,
but it can age between collection cycles and may not represent your chosen page today.

### Other real estate scrapers and tools

Build a broader real estate data workflow with these automation-lab Actors:

- [Realtor Agents Scraper](https://apify.com/automation-lab/realtor-agents-scraper)
- [HouseSigma Agents Scraper](https://apify.com/automation-lab/housesigma-agents-scraper)
- [Redfin Scraper](https://apify.com/automation-lab/redfin-scraper)
- [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper)
- [Crexi Commercial Real Estate Scraper](https://apify.com/automation-lab/crexi-commercial-real-estate-scraper)
- [New York eAccessNY Real Estate License Scraper](https://apify.com/automation-lab/new-york-eaccessny-real-estate-license-scraper)
- [Georgia Real Estate License Lookup Scraper](https://apify.com/automation-lab/georgia-real-estate-license-lookup-scraper)

Use source-specific Actors together when you need cross-platform coverage,
but keep each source's IDs and provenance fields separate.

# Actor input Schema

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

Add Redfin market agent-directory URLs ending in /real-estate/agents or direct /real-estate-agents/{slug} profile URLs.

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

Stop after saving this many unique agent records across all sources.

## `minimumRating` (type: `number`):

Keep only agents at or above this Redfin rating. Agents without a parseable rating are excluded.

## `minimumReviews` (type: `integer`):

Keep only agents with at least this many Redfin reviews. Agents without a parseable review count are excluded.

## `onlyActive` (type: `boolean`):

Keep only agents Redfin currently marks as active or taking calls.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.redfin.com/city/16163/WA/Seattle/real-estate/agents"
    }
  ],
  "maxItems": 5,
  "onlyActive": false
}
```

# Actor output Schema

## `overview` (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.redfin.com/city/16163/WA/Seattle/real-estate/agents"
        }
    ],
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/redfin-real-estate-agents-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.redfin.com/city/16163/WA/Seattle/real-estate/agents" }],
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/redfin-real-estate-agents-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.redfin.com/city/16163/WA/Seattle/real-estate/agents"
    }
  ],
  "maxItems": 5
}' |
apify call automation-lab/redfin-real-estate-agents-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Redfin Real Estate Agents Scraper",
        "description": "Extract live Redfin agent leads from market directories or profiles: emails, phones, ratings, reviews, brokerage, service regions, and transaction performance. Export to JSON, CSV, Excel, API, or webhooks.",
        "version": "0.1",
        "x-build-id": "KIScawqF2dRm1k6gm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~redfin-real-estate-agents-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-redfin-real-estate-agents-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/automation-lab~redfin-real-estate-agents-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-redfin-real-estate-agents-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/automation-lab~redfin-real-estate-agents-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-redfin-real-estate-agents-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🏙️ Redfin agent URLs",
                        "type": "array",
                        "description": "Add Redfin market agent-directory URLs ending in /real-estate/agents or direct /real-estate-agents/{slug} profile URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "👥 Maximum agents",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique agent records across all sources.",
                        "default": 25
                    },
                    "minimumRating": {
                        "title": "⭐ Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Keep only agents at or above this Redfin rating. Agents without a parseable rating are excluded."
                    },
                    "minimumReviews": {
                        "title": "💬 Minimum reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only agents with at least this many Redfin reviews. Agents without a parseable review count are excluded."
                    },
                    "onlyActive": {
                        "title": "✅ Only active agents",
                        "type": "boolean",
                        "description": "Keep only agents Redfin currently marks as active or taking calls.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```