` class or adds a sophisticated bot detection layer, your pipeline breaks.
Using a data API shifts the burden of maintenance from you to the engine. Instead of managing headless browsers, proxy rotation, and DOM selectors, you simply define what the data *should* look like. If the underlying HTML changes, the LLM-powered extraction engine adapts to find the data based on your schema, not your selectors.
1. **Define Schema** —
2. **Call Extract API** —
3. **Receive Typed JSON** —
## Quick start with AlterLab Extract API
To begin, you need an API key from AlterLab. You can follow our [Getting started guide](/docs/quickstart/installation) to set up your environment.
The [Extract API docs](/docs/api/extract) detail how to use the `POST /v1/extract` endpoint. This endpoint is unique because it allows you to define a schema, and the engine performs the extraction and validation in one step.
### Python Implementation
```python title="extract_homes-com.py" {5-12}
import alterlab
client = alterlab.Client("YOUR_API_KEY")
schema = {
"type": "object",
"properties": {
"address": {
"type": "string",
"description": "The full property address"
},
"price": {
"type": "string",
"description": "The listing price as a string"
},
"bedrooms": {
"type": "string",
"description": "Number of bedrooms"
},
"bathrooms": {
"type": "string",
"description": "Number of bathrooms"
},
"sqft": {
"type": "string",
"description": "Total square footage"
},
"listing_date": {
"type": "string",
"description": "The date the property was listed"
}
}
}
result = client.extract(
url="https://www.homes.com/property/example-listing-id",
schema=schema,
)
print(result.data)
```
### cURL Implementation
If you are testing from the terminal, use the following command:
```bash title="Terminal"
curl -X POST https://api.alterlab.io/v1/extract \
-H "X-API-Key: YOUR_KEY" \
-H "Content-Type: application/json" \
-d '{
"url": "https://www.homes.com/property/example-listing-id",
"schema": {
"type": "object",
"properties": {
"address": {"type": "string"},
"price": {"type": "string"},
"bedrooms": {"type": "string"}
}
}
}'
```
## Define your schema
The power of the Extract API lies in the JSON schema. You aren't just asking for "data"; you are enforcing a contract. If you require `price` to be an integer or `address` to be a string, the engine validates the output against that schema before returning it.
When the engine encounters a page, it uses Cortex AI to map the visual elements to your schema. This means you don't need to care if the price is inside a `
` or a ``. You only care that you receive a JSON object with a `price` key.
## Handle pagination and scale
For large-scale real-estate analytics, you won't be scraping one page at a time. You'll be processing thousands.
When scaling, you should implement an asynchronous job pattern. Instead of waiting for a synchronous HTTP response, you can submit batches of URLs. You can check the [AlterLab pricing](/pricing) to calculate your projected costs based on your volume.
```python title="batch_extraction.py"
import alterlab
import asyncio
client = alterlab.Client("YOUR_API_KEY")
urls = [
"https://homes.com/listing/1",
"https://homes.com/listing/2",
"https://homes.com/listing/3"
]
async def process_url(url):
# Using the async client for high-concurrency pipelines
response = await client.extract_async(
url=url,
schema={"type": "object", "properties": {"price": {"type": "string"}}}
)
return response.data
async def main():
tasks = [process_url(u) for u in urls]
results = await asyncio.gather(*tasks)
print(results)
if __name__ == "__main__":
asyncio.run(main())
```
## Key takeaways
* **Schema-First Extraction**: Stop writing brittle CSS selectors. Define a JSON schema and let the engine handle the DOM.
* **Reliable Data Pipelines**: Use a data API to manage the complexities of modern web rendering and anti-bot measures.
* **Scalable Workflow**: Use asynchronous calls and batch processing to ingest large volumes of real-estate data.
Hit reply if you have questions.
AlterLab // Web Data, Simplified.
## Frequently Asked Questions
### Is there an official Homes.com data API?
Homes.com does not offer a public developer API for bulk data access. AlterLab provides a data API that converts public web pages into structured JSON, filling the gap for developers needing real-estate data.
### What Homes.com data can I extract with AlterLab?
You can extract any publicly visible information, such as property addresses, listing prices, bedroom/bathroom counts, and square footage, formatted as typed JSON.
### How much does Homes.com data extraction cost?
AlterLab uses a pay-as-you-go model with no minimum commitment. You can use the Extract API to get a cost estimate before executing any calls.
## Related
- [Rate My Professors Data API: Extract Structured JSON in 2026]()
- [Crexi Data API: Extract Structured JSON in 2026]()
- [How to Scrape Shopee Data: Complete Guide for 2026]()