# Green Acres Scraper (`dadhalfdev/green-acres-scraper`) Actor

Green Acres (est. 2004, Paris) is an international property marketplace. This actor scrapes your search URL into structured data: pricing, location, specs, agency details, full description, image URL, contact phone, and many more fields. Scrape property listings anywhere in the world.

- **URL**: https://apify.com/dadhalfdev/green-acres-scraper.md
- **Developed by:** [Marco Rodrigues](https://apify.com/dadhalfdev) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.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.
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

## 🏠 Green Acres Property Scraper

**[Green Acres](https://www.green-acres.com)** is an international real estate marketplace founded in **2004** and headquartered in **Paris, France**. Listings span homes, apartments, land, and commercial property across **many countries**. You can start from a search or region URL in France, Portugal, the UK, or elsewhere and still get consistent, structured records.

This actor turns those listing and detail pages into **structured, machine-ready data** without manual copying. Paste a Green Acres search or category URL, set how many properties you want, and the scraper walks the grid, opens each advert, and extracts price, location, specs, agency details, the full description—and **agency contact phone numbers** when the site exposes them (often the first thing people want for follow-up, lead lists, or CRM imports).

![Green Acres Website](https://i.ibb.co/5WqhnLK5/Screenshot-From-2026-04-15-19-05-32.png)

### 💡 Perfect for…

- **Buyers & investors:** Compare asking prices, surface areas, and price-per-m² across regions in one dataset instead of dozens of open tabs—and call agencies directly using the extracted **`contact_phone`** numbers when available.
- **Market analysts & researchers:** Track supply by locality, bedroom count, or price band; join outputs with other datasets using `url`, `address_*`, and timestamps.
- **Prop-tech & CRM tools:** Feed clean property records into your product. **`contact_phone`** is ideal for diallers, outreach, and matching leads to listings; combine it with `agency_name`, `agency_address`, and `image_url` for full enrichment workflows.
- **Data & ML pipelines:** Run NLP or classification on `description`; use `surface_area`, `rooms`, `bedrooms`, and `additional_features` as structured features.
- **RAG & assistants:** Chunk `description` and index with `url` and `address_locality` so answers cite the exact listing page.

### ✨ Why you'll love this scraper

- 🎯 **Start from any listing URL:** Use the same filters you use on the site (location, property type, price range), copy the address bar URL into `input_url`, and the scraper follows pagination to collect more cards until it reaches your cap.
- ⚙️ **Rich detail pages:** Each record includes main characteristics (address, surface, land, rooms, bedrooms), parsed **numeric** fields where applicable, agency block (reference, mandate, fees, price/m²), popularity-derived **published date**, and the long-form **description**.
- 📞 **Agency phone numbers:** Each advert pulls the **call** number exposed on the page (the same line agencies use for inbound enquiries) into **`contact_phone`**—so you can reach sellers or agencies without copying numbers manually from every listing.
- 🖼️ **Media:** Captures the **hero image** URL when the gallery is present.
- 🌍 **Multi-country:** Green Acres serves listings worldwide; **`currency`** is the **symbol** shown next to the price on the page (e.g. €, £, $) as returned by the site, not a guessed label.

### 📦 What’s inside the data?

For every property detail page scraped, you get:

| Field | Description |
|--------|-------------|
| `url` | Canonical advert URL on Green Acres |
| `address_country` | Country from the listing (e.g. from schema.org address) |
| `address_locality` | City / area label (e.g. neighbourhood or town) |
| `surface_area` | Habitable surface as **float** (e.g. m²), parsed from the main characteristics |
| `land_area` | Land size as shown (string), when present |
| `rooms` | Number of rooms as **integer**, when present |
| `bedrooms` | Number of bedrooms as **integer**, when present |
| `additional_features` | Extra bullet lines from “main features” text (excluding duplicates of the icon row) |
| `agency_name` | Agency or seller name |
| `agency_kind` | Role line (e.g. “Agency”) when shown |
| `agency_address` | Agency address as a **single string** (multi-line where applicable) |
| `agency_reference` | Listing reference when shown |
| `agency_mandate_number` | Mandate number when shown |
| `agency_fees` | Fee text when the agency block includes a “Fees” row |
| `price_per_m2` | Price per m² as **float**, when present in the agency details |
| `view_count` | View count from the popularity block, when parsed |
| `published_date` | First-seen date as **ISO 8601 UTC** timestamp string, when parsed from popularity |
| `contact_phone` | **Agency / listing phone** for inbound calls (from the site’s call button, when shown)—high-value for outreach and CRM |
| `price` | Asking price as **float** |
| `currency` | Currency **symbol** from the price block (same as on the listing; e.g. €, £, $)—whatever the site renders |
| `image_url` | URL of the primary gallery image when found |
| `description` | Full visible description text from the advert body |

### 🚀 Quick start

1. **Open [Green Acres](https://www.green-acres.com)** (or a country site such as `.fr`, `.pt`, `.co.uk`) and run a search: choose region, property type, budget, or other options until you see the results you care about.
2. **Set `max_properties`** to how many property **detail pages** you want in the output (the scraper loads listing cards, turns pages when it can, then opens that many adverts). Per run, this is capped between **10** and **80**; the **default** is **50** if you leave the field on the platform default.
3. **Start** the run from the Apify Console (or call the API) and export your dataset as JSON, CSV, or Excel.

#### Building your input URL (filters and sort)

The scraper does **not** expose Green Acres’ filters in a separate form. Instead, you define the search **on the website**: whatever appears in the address bar after you search is what the actor uses. That keeps the workflow identical to browsing.

1. **Search and narrow results** in your browser—location, property type, price range, surface, bedrooms, new build, etc. Use whatever filter panels or chips the site offers for that country.
2. **Sort the list** if you care about order (e.g. price ascending, newest first). Sorting usually updates the URL or the order of results the listing page will show; the scraper follows the same result list you see.
3. When the **grid of listings** matches what you want to scrape, **select the full URL** in the address bar (`https://…`) and copy it.
4. **Paste that string** into **`input_url`**:
   - **Apify Console:** Input tab → `input_url` field, then save and run.
   - **Apify API / clients:** Pass the same value in the JSON body as `"input_url"` when starting a run (e.g. `POST` to the runs endpoint with your actor ID and input payload).

If you change filters or sort later, copy the **new** URL again—each combination has its own link, so you always know exactly which slice of the market you are exporting.

---

#### Tech details for developers 🧑‍💻

**Input Example**

```json
{
  "input_url": "https://www.green-acres.fr/property-for-sale/nantes",
  "max_properties": 50
}
````

**Output Example**

```json
{
  "url": "https://www.green-acres.pt/en/properties/apartment/se-funchal/Aacfytrmg17xwc1m.htm",
  "address_country": "Portugal",
  "address_locality": "Sé (Funchal)",
  "surface_area": 132.0,
  "land_area": null,
  "rooms": null,
  "bedrooms": 3,
  "additional_features": [
    "3 bathrooms",
    "Terrace",
    "Orientation: South, West"
  ],
  "agency_name": "HB Family Properties",
  "agency_kind": "Agency",
  "agency_address": "Rua Doutor João Abel de Freitas\n9300 Câmara De Lobos",
  "agency_reference": "20558330",
  "agency_mandate_number": "931-AW",
  "agency_fees": null,
  "price_per_m2": 6439.0,
  "view_count": 21,
  "published_date": "2026-02-19T00:00:00.000Z",
  "contact_phone": "+351 300 505 535",
  "price": 850000.0,
  "currency": "€",
  "image_url": "https://lb-eu.vizzit.com/962211a/Aacfytrmg17xwc1m/Photos/Aacfytrmg17xwc1m_1.jpg",
  "description": "City building with modern flats and good areas…"
}
```

**Parameters**

| Parameter | Type | Required | Default | Min | Max | Description |
|-----------|------|----------|---------|-----|-----|-------------|
| `input_url` | string | Yes | `https://www.green-acres.pt/property-for-sale/funchal-municipality` | — | — | Full Green Acres **search results** URL from your browser after you apply filters and sort (see [Building your input URL](#building-your-input-url-filters-and-sort)). |
| `max_properties` | integer | Yes | **50** | **10** | **80** | How many property **detail** pages to scrape and push to the dataset in a single run. |

# Actor input Schema

## `input_url` (type: `string`):

The input URL with the filters applied.

## `max_properties` (type: `integer`):

The maximum number of properties to be scraped.

## Actor input object example

```json
{
  "input_url": "https://www.green-acres.pt/property-for-sale/funchal-municipality",
  "max_properties": 50
}
```

# Actor output Schema

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

Table view of scraped Green Acres properties using the dataset 'overview' view.

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

All scraped Green Acres properties from the default dataset without view transformation.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("dadhalfdev/green-acres-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("dadhalfdev/green-acres-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 '{}' |
apify call dadhalfdev/green-acres-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Green Acres Scraper",
        "description": "Green Acres (est. 2004, Paris) is an international property marketplace. This actor scrapes your search URL into structured data: pricing, location, specs, agency details, full description, image URL, contact phone, and many more fields. Scrape property listings anywhere in the world.",
        "version": "0.1",
        "x-build-id": "Sc7rraxbd2cRORRQO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dadhalfdev~green-acres-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dadhalfdev-green-acres-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/dadhalfdev~green-acres-scraper/runs": {
            "post": {
                "operationId": "runs-sync-dadhalfdev-green-acres-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/dadhalfdev~green-acres-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-dadhalfdev-green-acres-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": {
                    "input_url": {
                        "title": "Input URL",
                        "type": "string",
                        "description": "The input URL with the filters applied.",
                        "default": "https://www.green-acres.pt/property-for-sale/funchal-municipality"
                    },
                    "max_properties": {
                        "title": "Maximum number of properties",
                        "minimum": 10,
                        "maximum": 80,
                        "type": "integer",
                        "description": "The maximum number of properties to be scraped.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```