# Redfin Scraper — Properties, Prices & Real Estate Data (`bovi/redfin-scraper`) Actor

Scrape Redfin real estate listings by city, ZIP code, county, or any Redfin search URL. Returns price, beds, baths, sqft, lot size, year built, days on market, coordinates, and more via Redfin's internal stingray JSON API. No proxy required for most regions. Pay per property.

- **URL**: https://apify.com/bovi/redfin-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.97 / 1,000 property listings

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

## Redfin Scraper — Real Estate Listings by City & ZIP | $1.50/1K | No Proxy

For investors, agents, and data teams who need Redfin's clean JSON API data without spinning up proxies or parsing HTML.

Pay per property: **$1.50 per 1,000 properties** — charged only for results delivered.

Scrape Redfin real estate listings by city, ZIP code, county, or neighborhood. Returns structured property data — price, beds, baths, square footage, lot size, year built, days on market, GPS coordinates, and more. Powered by Redfin's internal stingray JSON API for reliable, fast extraction.

### Why use this actor?

- **No proxy required** for most US regions — the API returns JSON directly
- **Fast and reliable** — structured JSON endpoint, no HTML parsing fragility
- **Rich data** — 20+ fields per property including remarks, status, and coordinates
- **Flexible input** — city, ZIP, county, neighborhood, or full Redfin search URL
- **Pay per result** — only pay for properties you actually receive

### What data do you get?

| Field | Description |
|---|---|
| `property_id` | Redfin property ID (stable) |
| `address` | Street address |
| `city`, `state`, `zip` | Location |
| `price` | Listing price in USD |
| `beds` | Bedrooms |
| `baths` | Bathrooms (supports half-baths) |
| `sqft` | Interior square footage |
| `lot_size` | Lot size in square feet |
| `year_built` | Year of construction |
| `property_type` | house / condo / townhouse / multi-family / land / other |
| `status` | active / coming_soon / pending / sold / etc. |
| `days_on_market` | Days listed (DOM) |
| `latitude`, `longitude` | GPS coordinates |
| `url` | Direct Redfin listing URL |
| `parse_confidence` | Data quality score (1.0 = perfect) |

### How to use

1. Go to [redfin.com](https://www.redfin.com) and navigate to a city, ZIP code, county, or neighborhood
2. Copy the URL from your browser's address bar
3. Paste it into the **Locations** input field

**Example URLs:**
````

https://www.redfin.com/city/30818/TX/Austin
https://www.redfin.com/zipcode/78701
https://www.redfin.com/county/1361/TX/Travis-County
https://www.redfin.com/neighborhood/48430/CA/San-Francisco/Noe-Valley

````

You can scrape multiple locations in one run by adding multiple URLs.

### Output sample

```json
{
  "property_id": "55823410",
  "address": "2107 Nueces St",
  "city": "Austin",
  "state": "TX",
  "zip": "78705",
  "price": 649000,
  "beds": 3,
  "baths": 2.0,
  "sqft": 1850,
  "lot_size": 5400,
  "year_built": 1978,
  "property_type": "house",
  "status": "active",
  "days_on_market": 12,
  "latitude": 30.2843,
  "longitude": -97.7407,
  "url": "https://www.redfin.com/TX/Austin/2107-Nueces-St-78705/home/55823410",
  "parse_confidence": 1.0,
  "warnings": []
}
````

### Pricing example

| Run size | Cost |
|---|---|
| 100 properties | ~$0.15 |
| 1,000 properties | ~$1.50 |
| 10,000 properties | ~$15.00 |
| + sold comp (ARV) | +$1.00/1K |

### FAQ

**Do I need a Redfin account or proxy?**
No account. No proxy required for most US regions — the stingray JSON API is open. Configure Apify proxy in Advanced options only if you hit blocks.

**What output formats are available?**
JSON, CSV, Excel, XML — all via Apify dataset download or API.

**Can I pull sold comps for ARV analysis?**
Yes — set `statusFilter` to `sold` to get recently closed sales. Sold comps charge both the base event and the `sold-listing` premium event.

**What if a location returns empty results?**
The actor logs the error, skips the location, and continues. Empty locations push no records and charge nothing.

### Why this actor vs. competitors

| Feature | This actor | epctex/redfin-scraper ($2/1K) | Typical Redfin HTML scraper |
|---|---|---|---|
| Internal stingray JSON API | Yes | No (HTML) | No |
| parse\_confidence | Yes | No | No |
| Days on market field | Yes | Rarely | No |
| Multiple locations per run | Yes | Single URL | Single URL |
| Sold comps (statusFilter=sold) | Yes | No | No |
| Proxy required | No (most regions) | Yes | Often yes |

Key differentiators: `lot_size`, `year_built`, and `days_on_market` on every property. Sold comps via `statusFilter=sold` return closed-sale data that Zillow charges for — investors use this for ARV analysis.

### parse\_confidence

Every record includes `parse_confidence` (1.0 = all fields present). Records with `parse_confidence < 0.8` have degraded data — inspect the `warnings` array.

### Use with AI agents (MCP)

Tag: `MCP_SERVERS`. Returns flat JSON — plug directly into LangChain agents, n8n nodes, or Make scenarios without transformation.

```json
{
  "mcpServer": "https://mcp.apify.com/?tools=bovi/redfin-scraper"
}
```

### Proxy

No proxy required for most US regions. If you encounter blocks, configure an Apify proxy in the **Advanced options** section.

### Cost

Pay-Per-Event (PPE) pricing:

| Event | Price |
|---|---|
| `property-item` (primary) | **$1.50 / 1,000 properties** |
| `sold-listing` (premium) | **$1.00 / 1,000 sold comps** |

Sold comps (`statusFilter=sold`) charge both events — the base listing event plus the sold-comp premium. Default run fetches up to 500 properties.

### Integrations

Built for real-estate investors and data teams pulling structured property listings by city, ZIP, and neighborhood — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

### Legal

This actor accesses publicly available real estate data from redfin.com. Use responsibly and in accordance with Redfin's Terms of Service. Do not use for mass harvesting or commercial redistribution of listing data.

# Actor input Schema

## `locations` (type: `array`):

Full Redfin search URLs to scrape — city, ZIP, county, or neighborhood. Go to redfin.com, navigate to any area, copy the URL. Examples: https://www.redfin.com/city/30818/TX/Austin or https://www.redfin.com/zipcode/78701. Add multiple URLs to scrape several areas in one run.

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

Maximum number of property records to return across all locations. 0 = no limit (up to Redfin API maximum per region). Default 500.

## `propertyTypes` (type: `array`):

Filter by property type. Accepted values: house, condo, townhouse, multi-family, land, other. Leave empty to include all types.

## `minPrice` (type: `integer`):

Minimum listing price filter. 0 = no minimum.

## `maxPrice` (type: `integer`):

Maximum listing price filter. 0 = no maximum.

## `minBeds` (type: `integer`):

Minimum number of bedrooms. 0 = no minimum.

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

Optional Apify proxy. Most Redfin regions do not require a proxy — the stingray API returns JSON directly. Use a proxy only if you encounter blocks in restricted regions.

## `statusFilter` (type: `string`):

Filter by listing status. active: for-sale only; sold: recently sold; all: both active and sold.

## `pageSize` (type: `integer`):

Number of listings fetched per API call (max 350). Reduce if you see errors. Default 350.

## Actor input object example

```json
{
  "locations": [
    "https://www.redfin.com/city/30818/TX/Austin"
  ],
  "maxResults": 500,
  "propertyTypes": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "statusFilter": "active",
  "pageSize": 350
}
```

# Actor output Schema

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

Dataset containing Redfin Scraper records (address, city, state, price, beds, baths, sqft, days\_on\_market, status, property\_type, url, parse\_confidence).

# 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 = {
    "locations": [
        "https://www.redfin.com/city/30818/TX/Austin"
    ],
    "maxResults": 500,
    "propertyTypes": [],
    "minPrice": 0,
    "maxPrice": 0,
    "minBeds": 0,
    "proxyConfiguration": {
        "useApifyProxy": false
    },
    "statusFilter": "active",
    "pageSize": 350
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/redfin-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 = {
    "locations": ["https://www.redfin.com/city/30818/TX/Austin"],
    "maxResults": 500,
    "propertyTypes": [],
    "minPrice": 0,
    "maxPrice": 0,
    "minBeds": 0,
    "proxyConfiguration": { "useApifyProxy": False },
    "statusFilter": "active",
    "pageSize": 350,
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/redfin-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 '{
  "locations": [
    "https://www.redfin.com/city/30818/TX/Austin"
  ],
  "maxResults": 500,
  "propertyTypes": [],
  "minPrice": 0,
  "maxPrice": 0,
  "minBeds": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "statusFilter": "active",
  "pageSize": 350
}' |
apify call bovi/redfin-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Redfin Scraper — Properties, Prices & Real Estate Data",
        "description": "Scrape Redfin real estate listings by city, ZIP code, county, or any Redfin search URL. Returns price, beds, baths, sqft, lot size, year built, days on market, coordinates, and more via Redfin's internal stingray JSON API. No proxy required for most regions. Pay per property.",
        "version": "0.1",
        "x-build-id": "t4MbbfQxaqHQe0ikI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~redfin-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-redfin-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/bovi~redfin-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bovi-redfin-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/bovi~redfin-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-redfin-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": {
                    "locations": {
                        "title": "Redfin search URLs",
                        "type": "array",
                        "description": "Full Redfin search URLs to scrape — city, ZIP, county, or neighborhood. Go to redfin.com, navigate to any area, copy the URL. Examples: https://www.redfin.com/city/30818/TX/Austin or https://www.redfin.com/zipcode/78701. Add multiple URLs to scrape several areas in one run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of property records to return across all locations. 0 = no limit (up to Redfin API maximum per region). Default 500."
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Filter by property type. Accepted values: house, condo, townhouse, multi-family, land, other. Leave empty to include all types.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minPrice": {
                        "title": "Min price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum listing price filter. 0 = no minimum."
                    },
                    "maxPrice": {
                        "title": "Max price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum listing price filter. 0 = no maximum."
                    },
                    "minBeds": {
                        "title": "Min bedrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of bedrooms. 0 = no minimum."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy. Most Redfin regions do not require a proxy — the stingray API returns JSON directly. Use a proxy only if you encounter blocks in restricted regions."
                    },
                    "statusFilter": {
                        "title": "Listing status filter",
                        "enum": [
                            "active",
                            "sold",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter by listing status. active: for-sale only; sold: recently sold; all: both active and sold."
                    },
                    "pageSize": {
                        "title": "Results per API page",
                        "minimum": 10,
                        "maximum": 350,
                        "type": "integer",
                        "description": "Number of listings fetched per API call (max 350). Reduce if you see errors. Default 350."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
