Flatmates AU Property Scraper

Slug: fatihtahta/flatmates-au-property-scraper

Overview

Flatmates AU Property Scraper collects structured public room and rental-property listings, including asking rent, availability, location, property characteristics, room terms, media, and public host context when available. Flatmates.com.au is an Australian accommodation marketplace whose public listings are useful for rental discovery, shared-housing research, supply monitoring, and operational review. The actor supports repeatable location-based searches with documented filters as well as exact public search URLs. Optional enrichment adds detail-level room, property, coordinate, inspection, media, and host fields while preserving the same property_listing record family. Results are written as structured dataset records suitable for review, export, ETL pipelines, BI dashboards, AI-agent workflows, and downstream APIs. The input and output contracts are designed for recurring public-data workflows where consistent field names, stable identifiers, and run-level receipts matter more than one-off page inspection.

What Makes This Actor Different

• One pipeline-ready record family: every dataset row uses the grouped property_listing contract, with related values organized under listing, pricing, location, property, availability, media, relationships, and attributes.
• Two deliberate input modes: use a supported Flatmates URL as the authoritative scope, or build a search from one Australian location plus rent, availability, accommodation, household, room, keyword, and sort filters.
• Optional detail enrichment: enrich_data preserves the base record shape while adding public room terms, richer descriptions, coordinates, property features, inspection context, additional media, and host information when exposed.
• Stable identity guidance: record_id combined with source_context.source_id is the recommended key for upserts, deduplication, repeated-run comparison, and mixed-source warehouses.
• Operational run receipts: RUN-SUMMARY and RUN-SUMMARY.html report input scope, saved totals, duplicate and enrichment counts, location coverage, weekly-rent ranges, representative listings, and artifact status.
• Map-ready enriched runs: enriched records can include public latitude and longitude values, and the results-map artifact summarizes mapped, skipped, and deduplicated listing markers.
• Agent-friendly handoff: documented inputs, a precise field reference, JSON examples, run artifacts, and optional summary-only MCP delivery make the actor usable by automated property workflows without requiring private operational context.

Who Should Use This Actor

• Rental-market analysts: build repeatable snapshots of advertised weekly rents, availability, room types, accommodation categories, and geographic distribution.
• Property and housing operators: review public shared-housing inventory, room terms, household preferences, furnishing, parking, and availability for defined Australian markets.
• Brokerages and relocation teams: collect candidate public listings for structured review, client shortlists, and location-specific accommodation research.
• Proptech and data teams: load normalized listing JSON into warehouses, search indexes, internal products, CRMs, enrichment pipelines, and monitoring systems.
• BI and research teams: create dashboards and recurring reports from stable identifiers, asking-rent fields, location groups, property attributes, and run-level totals.
• AI agents and workflow automations: generate scoped inputs, validate returned records, read run receipts, and route selected listings or summary links into the next review step.

Common Use Cases

• Market intelligence: monitor public room supply, weekly asking rents, availability, property mix, and household preferences within a selected location.
• Comparable listing research: collect rooms or whole-property listings within a consistent geography, accommodation type, and weekly-rent band.
• Availability monitoring: repeat the same search to identify listings whose availability, status, price, or room terms changed between runs.
• Segmented housing research: separate furnished rooms, private rooms, student accommodation, women-only households, or pet-accepting listings into reviewable datasets.
• CRM and relocation enrichment: attach current public listing URLs, descriptions, rents, locations, room terms, media, and host context to existing workflows.
• Map-based review: use enriched coordinates and the interactive map to inspect the distribution of returned listings without treating coordinates as precise property verification.
• Recurring reporting: schedule stable input configurations for inventory snapshots, analyst reports, alerts, and BI refreshes.
• Agentic research: let an internal agent run a bounded search, inspect the run summary, shortlist matching records, and route results for human verification.

Real-World Questions This Data Can Answer

• Which public Flatmates listings match a selected Australian location, weekly-rent band, accommodation type, and room preference?
• Which returned listings advertise bills included, furnished rooms, parking, or specific household acceptance criteria?
• What is the advertised weekly-rent range across the records saved in this run?
• Which listings are available by a target date or support a selected minimum stay?
• Which enriched records contain coordinates, room-level terms, inspection context, additional media, or public host information?
• Which listing IDs are new, missing, repriced, or changed compared with a previous internal snapshot?
• How many records were saved, enriched, skipped as duplicates, or suitable for map review in a completed run?

Quick Start

1. Add one or more supported Flatmates search URLs, or use the structured query fields with an Australian location such as Melbourne, Gold Coast, or Darlinghurst. Leaving both URL and location empty runs the broad default rooms query.
2. Add only the rent, availability, accommodation, household, room, keyword, or sort filters needed for the first segment.
3. Set a small limit, such as 5, and decide whether enrich_data should be enabled.
4. Run the actor in Apify Console and inspect the first dataset records.
5. Review the run summary and, for enriched runs, the interactive map before increasing the limit or scheduling recurring collection.

Input Parameters

Use a direct URL for an exact public search scope, or use location and the query fields to build a repeatable Flatmates search.

Parameter	Type	Description	Default
url	array of strings	Supported public Flatmates search URLs. Each unique URL is an independent seed. If at least one URL is supplied, URL mode is authoritative and all location/query-builder fields are discarded.	–
location	string	Australian city, suburb, state, postcode, or market used to build a room search, such as Melbourne, Darlinghurst, VIC, or 3053.	–
min_price	integer	Minimum advertised weekly rent in AUD. Minimum value: 0.	–
max_price	integer	Maximum advertised weekly rent in AUD. It must be at least min_price when both are supplied.	–
bills_included	boolean	Restrict the generated query to listings advertising bills included.	–
availability_date	string	Latest acceptable availability date in YYYY-MM-DD format.	–
stay_length	string	Required minimum stay: 1, 2, 4, or 6 weeks; 8 weeks/2 months; 13 weeks/3 months; 17 weeks/4 months; 26 weeks/6 months; 39 weeks/9 months; or 52 weeks/1 year.	–
property_type	array of strings	Accommodation categories: share-houses, whole-properties, granny-flats, homestays, studios, 1-beds, or student-accommodation.	[]
women_only_household	boolean	Restrict the generated query to households advertised as women-only.	–
room_type	string	Room arrangement: private-room or shared-room.	–
preferred_demographic	string	Household preference: females, males, or couples.	–
furnishment	string	Furnishing state: furnished or unfurnished.	–
bathroom_type	string	Bathroom arrangement: ensuite or ensuite-or-own.	–
min_bedroom	string	Minimum advertised available bedrooms: 1, 2, 3, or 4.	–
parking_type	string	Parking requirement: no-parking, off-street-parking, or on-street-parking.	–
accepting	array of strings	Household characteristics that must be accepted: lgbt-friendly, retirees, students, smokers, backpackers, children, over-40, or pets.	[]
sort_by	string	Result order: photos (Featured First), newest, cheapest, most-expensive, earliest-available, or recently-active.	photos
keyword	string	Required listing keywords, such as air con, pool, balcony, or desk.	–
enrich_data	boolean	Add public detail-level room, property, coordinate, media, inspection, and host fields when available. Successfully enriched saved rows use the actor's enriched-record event when event charging applies.	true
mcpConnectors	array of connector resources	Optional user-authorized Apify MCP connectors for concise post-run summary delivery. Full listing rows are not sent through this generic handoff.	[]
limit	integer	Optional maximum number of property-listing records to save. Minimum value: 1; when omitted, collection continues until the selected scope is exhausted or the platform runtime limit is reached.	–

Choosing Inputs

Choose URL mode when you already have public Flatmates search URLs whose exact paths, filters, and order should be revisited. Every unique supported URL is used as an independent seed. If a URL is present, location, price, property, room, household, keyword, and sort fields are discarded rather than applied to or combined with those URLs. Results from multiple seeds are interleaved before global deduplication and the run limit are applied.

Choose query mode whenever url is empty. Add one location to resolve a city, suburb, state, postcode, or market, then optionally add price, property, availability, stay, room, or household filters. If both url and location are empty, the query builder still runs and starts from the broad Flatmates rooms search; any supplied filters narrow that broad query. If no query fields are supplied at all, the actor uses https://flatmates.com.au/rooms?search_source=search_function as the default scope.

Keep enrich_data enabled when room terms, coordinates, property features, additional media, inspection context, or public host fields matter. Disable it for a lighter validation run when search-level listing identity, asking rent, availability text, address, and images are sufficient. Begin with a small limit, verify the field shape and fill rates, and then increase the limit for recurring or production workflows.

Input Recipes

• Validation run: set one location, leave most filters empty, disable enrich_data if search-level fields are sufficient, and use limit: 5 to inspect the contract.
• Targeted private-room search: combine location, min_price, max_price, property_type, room_type, and one or two accepting values.
• Broad market discovery: use one city or suburb with few optional filters, keep the default sort, and set a sensible limit for an initial view of public inventory.
• Availability monitoring: reuse the same location, availability_date, stay_length, property fields, and sort order on a schedule, then compare records by stable key.
• Exact search refresh: place one or more previously reviewed Flatmates search URLs in url; treat each URL as a complete, independent search definition for the run.
• Default broad query: leave both url and location empty to use the default Flatmates rooms search. Add limit for a bounded export, or omit it to continue through the available result pages for as long as the run can proceed.
• Enrichment run: enable enrich_data for a focused location or URL when room-level pricing, features, coordinates, media, inspections, or host context are required downstream.

Example Inputs

Lightweight Melbourne market scan

{
  "location": "Melbourne",
  "property_type": ["share-houses"],
  "sort_by": "newest",
  "enrich_data": false,
  "limit": 5
}

Targeted private-room search

{
  "location": "Darlinghurst",
  "min_price": 220,
  "max_price": 450,
  "bills_included": true,
  "room_type": "private-room",
  "accepting": ["students", "lgbt-friendly"],
  "enrich_data": true,
  "limit": 20
}

Availability monitoring segment

{
  "location": "Gold Coast",
  "availability_date": "2026-08-31",
  "stay_length": "13",
  "furnishment": "furnished",
  "sort_by": "recently-active",
  "enrich_data": true,
  "limit": 25
}

Output

Output Destination

The actor writes results to an Apify dataset as JSON records. The dataset is designed for direct consumption by analytics tools, ETL pipelines, AI agents, and downstream APIs with minimal post-processing.

The current public contract contains one record shape: property_listing. Run summaries, reports, maps, and support artifacts are stored separately as key-value-store outputs and are not dataset rows.

Record Envelope and Stable Identifiers

Each row can include record_type, record_id, url, provenance in source_context, and grouped listing data. The recommended idempotency key is the composite source_context.source_id + record_id; within this actor alone, record_id is the practical listing key. listing.listing_id, property.property_id, and entity.external_ids.listing_id provide supporting source identity when present.

Use the recommended key for upserts rather than relying on title, address, or result position. Stable identifiers make records easier to merge, deduplicate, sync, and compare across repeated runs. Preserve source_context.source_url and top-level url for public-source traceability and later human review.

Examples

The following synthetic example reflects the schema and a fixture-backed enriched record. Lightweight records use the same top-level contract but normally omit detail-only groups and fields.

Example: enriched property listing record

{
  "record_type": "property_listing",
  "record_id": "1234567",
  "url": "https://flatmates.com.au/share-house-sydney-darlinghurst-2010-P1234567",
  "source_context": {
    "source_id": "flatmates_au_property_scraper",
    "source_name": "Flatmates.com.au",
    "source_domain": "flatmates.com.au",
    "source_url": "https://flatmates.com.au/share-house-sydney-darlinghurst-2010-P1234567",
    "position": 1,
    "country": "AU",
    "language": "en-AU",
    "enrichment_status": "enriched",
    "enriched_fields": [
      "entity",
      "listing",
      "location",
      "property",
      "availability",
      "media",
      "relationships"
    ]
  },
  "entity": {
    "title": "Bright furnished room in Darlinghurst",
    "subtitle": "Room in a welcoming shared home",
    "description": "A furnished private room close to transport, cafes, and the city centre.",
    "status": "active",
    "external_ids": {
      "listing_id": "1234567",
      "member_id": "501"
    }
  },
  "listing": {
    "listing_id": "1234567",
    "listing_type": "property",
    "deal_type": "rent",
    "listing_status": "active",
    "available_from": "2026-07-25",
    "posted_at": "2026-07-05T12:02:26.151000Z"
  },
  "pricing": {
    "price": 280,
    "price_text": "$280",
    "currency": "AUD",
    "period": "week",
    "fees": {
      "bills_text": "inc. bills"
    }
  },
  "location": {
    "address": "Darlinghurst NSW 2010",
    "city": "Sydney",
    "region": "NSW",
    "neighborhood": "Darlinghurst",
    "postal_code": "2010",
    "country": "Australia",
    "latitude": -33.878,
    "longitude": 151.219
  },
  "property": {
    "property_id": "1234567",
    "property_type": "Apartment",
    "bedrooms": 6,
    "bathrooms": 4,
    "occupants": 7,
    "household_description": "Friendly professional household.",
    "features": {
      "internet": {
        "status": "Available"
      },
      "parking": {
        "type": "On street"
      },
      "accessibility": [
        {
          "name": "Step-free access"
        }
      ]
    }
  },
  "availability": {
    "display_text": "Available 25 July 2026",
    "heading": "One room available",
    "room_count": 1,
    "rooms": [
      {
        "room_id": "99",
        "title": "Sunny private room",
        "status": "available",
        "room_type": "Private room",
        "bathroom_type": "Shared bathroom",
        "furnishings": "Furnished",
        "available_from": "2026-07-25",
        "minimum_stay_weeks": 13,
        "pricing": {
          "weekly_rent": 280,
          "bills": "Included"
        },
        "features": ["Wardrobe", "Desk"]
      }
    ]
  },
  "media": {
    "main_image_url": "https://flatmates-res.cloudinary.com/sample-main.jpg",
    "main_image_alt": "Bright furnished bedroom",
    "image_urls": [
      "https://flatmates-res.cloudinary.com/sample-main.jpg",
      "https://flatmates-res.cloudinary.com/sample-room.jpg"
    ],
    "image_count": 2
  },
  "relationships": {
    "host": {
      "host_id": "501",
      "name": "Alex",
      "last_online": "Online today",
      "response_rate": 95,
      "mobile_verified": true
    }
  },
  "contact_details": {
    "contacts": {
      "mobile_contact_allowed": true,
      "mobile_verified": true,
      "mobile_country": "AU"
    }
  },
  "attributes": {
    "tags": ["New"],
    "flags": {
      "is_featured": true,
      "has_photos": true
    }
  }
}

Run Summary, Map, And Artifacts

• RUN-SUMMARY: machine-readable run receipt with timestamps, duration, source and input scope, saved-listing totals, duplicate counts, enrichment outcomes, resolved locations, coordinate coverage, weekly-rent ranges, property breakdowns, representative listings, warnings, and artifact status.
• RUN-SUMMARY.html: human-readable report presenting the key run totals and representative values for operators and reviewers.
• results-map: interactive map written for enriched runs. It includes listings with valid public coordinates and reports mapped, skipped, and deduplicated marker totals; an enriched run with no valid coordinates can still produce a zero-marker map report.
• RUN-SUMMARY-ERROR: best-effort public-safe diagnostic receipt that can appear if final summary generation fails after listing rows have already been saved.

Find these artifacts through the Actor run's Output and key-value-store links in Apify Console. Property teams can use them to review location distribution and representative listings; data teams can verify counts, enrichment coverage, coordinate fill, and duplicate outcomes; AI agents can treat them as run receipts before routing alerts or starting downstream ingestion. Artifacts support operational review but do not replace the authoritative dataset records.

When mcpConnectors is selected, the actor sends a concise run summary and available Apify dataset/report/map links after dataset and artifact saving. Users authorize connectors in Apify; the actor receives connector identifiers while Apify supplies the connected service credentials. This generic handoff is summary-only, best-effort, and does not send the full listing dataset.

Field Reference

The dataset schema permits sparse records, so fields below are marked optional. Enriched rows normally contain more of the detail-dependent fields than lightweight rows.

Record Envelope

• record_type (string, optional): record-family value; currently property_listing.
• record_id (string, optional): Flatmates listing identifier and primary actor-level upsert key.
• url (string, optional): public listing URL for review and refresh workflows.

Source Context

• source_context.source_id (string, optional): stable source identifier; combine with record_id for cross-source upserts.
• source_context.source_name / source_context.source_domain (string, optional): human-readable source and public domain.
• source_context.source_url (string, optional): public source URL retained for provenance.
• source_context.position (integer, optional): one-based result position in the returned search records.
• source_context.country / source_context.language (string, optional): source locale, normally AU and en-AU.
• source_context.enrichment_status (string, optional): lightweight or enriched.
• source_context.enriched_fields (array of strings, optional): top-level groups changed by successful detail enrichment.

Entity and Listing

• entity.title / entity.subtitle (string, optional): primary and secondary display text.
• entity.description (string, optional): cleaned public description; enrichment may provide a fuller value.
• entity.status (string, optional): source-provided status when available.
• entity.external_ids (object, optional): source identifiers such as listing or member IDs.
• listing.listing_id (string, optional): listing identifier repeated inside the listing group.
• listing.listing_type (string, optional): source listing classification.
• listing.deal_type (string, optional): normalized rental mode, normally rent.
• listing.listing_status (string, optional): normalized public listing state.
• listing.available_from (date string, optional): normalized earliest availability date when safely parseable.
• listing.posted_at / listing.expires_at (date-time string, optional): source lifecycle timestamps when published.
• listing.promotion (object, optional): public promotion or boost context that may help explain visibility.

Pricing

• pricing.price (number, optional): numeric advertised weekly asking rent.
• pricing.price_text (string, optional): source-formatted asking-rent label.
• pricing.currency (string, optional): currency code, normally AUD.
• pricing.period (string, optional): normalized rent period, normally week.
• pricing.fees (object, optional): source wording about bills or related charges.

Location

• location.address (string, optional): best public address or locality label.
• location.city / location.region (string, optional): city and Australian state or region.
• location.neighborhood (string, optional): source suburb or neighborhood.
• location.postal_code (string, optional): Australian postcode retained as text.
• location.country (string, optional): source-provided country label.
• location.latitude / location.longitude (number, optional): public coordinates available on some enriched records and used by the map artifact.

Property

• property.property_id (string, optional): property identity, currently aligned with the listing ID when present.
• property.property_type (string, optional): source property category available after enrichment.
• property.bedrooms / property.bathrooms (number, optional): advertised property counts.
• property.occupants (number, optional): advertised current or expected household occupant count.
• property.household_description (string, optional): cleaned public household context.
• property.features (object, optional): grouped internet, parking, accessibility, and other published features.
• property.preferences (object, optional): source-provided household preferences.

Availability and Rooms

• availability.display_text (string, optional): original public availability wording.
• availability.heading (string, optional): source heading describing room inventory.
• availability.room_count (number, optional): advertised available-room count.
• availability.rooms (array of objects, optional): ordered room-level records available after enrichment.
• availability.rooms[].room_id (string, optional): Flatmates room identifier.
• availability.rooms[].title / availability.rooms[].status (string, optional): room display title and advertised state.
• availability.rooms[].room_type / availability.rooms[].bathroom_type (string, optional): room and bathroom arrangements.
• availability.rooms[].furnishings (string, optional): published furnishing state.
• availability.rooms[].available_from (date string, optional): normalized room-level availability date.
• availability.rooms[].minimum_stay_weeks (number, optional): minimum stay measured in weeks.
• availability.rooms[].pricing (object, optional): room-level weekly rent, bills, deposit, and related charge wording.
• availability.rooms[].features (array of strings, optional): advertised room features.
• availability.rooms[].utilities (object, optional): room utility availability when published.
• availability.inspections (object, optional): public inspection and booking state.

Media

• media.main_image_url / media.main_image_alt (string, optional): preferred public image and source descriptive text.
• media.image_urls (array of strings, optional): deduplicated public image URLs in source order.
• media.image_count (integer, optional): number of URLs in media.image_urls.
• media.photos (array of objects, optional): enrichment-only photo identity, URL, thumbnail, primary-image flag, and position metadata.
• media.video_urls (array of strings, optional): public listing-tour or inspection videos.

Relationships and Contact Context

• relationships.host (object, optional): public Flatmates member context; it is not ownership verification.
• relationships.host.host_id / relationships.host.name (string, optional): source member ID and public display name.
• relationships.host.profile_image_url (string, optional): public profile image.
• relationships.host.last_online (string, optional): source wording for recent activity.
• relationships.host.response_rate (number, optional): source-published response-rate value.
• relationships.host.mobile_verified (boolean, optional): source-provided mobile verification signal.
• relationships.host.verified_socials (array of strings, optional): source-provided social verification labels.
• contact_details.contacts (object, optional): published contact allowance, mobile verification, and country context; no hidden mobile number is exposed.

Additional Attributes

• attributes.tags (array of strings, optional): source listing labels in source order.
• attributes.flags (object, optional): normalized indicators such as featured, early-bird, disaster-relief, and photo availability.
• attributes.raw_attributes (object, optional): cleaned Flatmates-specific business values retained without duplicating mapped fields or private session metadata.

Data Model Notes

• Identity fields: use source_context.source_id + record_id for cross-source upserts; record_id is normally sufficient within this actor's dataset.
• Source provenance: retain url and source_context.source_url so analysts and operators can trace records to their public listing context.
• Primary business groups: listing, pricing, location, property, and availability carry the main rental and room attributes.
• Point-in-time values: price, availability, status, descriptions, room terms, and host activity reflect what was publicly visible during the run.
• Nested objects: related fields remain grouped so JSON-first systems can preserve context; flatten them deliberately for tabular destinations.
• Optional depth: enrichment-dependent fields should be null-checked rather than inferred from missing values.
• Repeated runs: compare stable IDs and selected business fields while keeping the Apify run ID, run date, and input configuration in your audit metadata.

Data Quality, Guarantees, And Handling

• Structured records: results are normalized into predictable JSON objects for downstream use.
• Field preservation: meaningful schema-supported listing and property values are kept in stable public fields or grouped objects instead of being silently discarded; optional source values may still be absent when a specific listing does not expose them.
• Best-effort extraction: fields may vary by region, availability, account visibility, listing type, interface experiments, or source-side changes.
• Optional fields: null-check optional fields in downstream code, dashboards, and AI workflows.
• Deduplication: use source_context.source_id + record_id as the recommended composite key, with record_id as the practical actor-level key.
• Freshness: results reflect publicly available information at run time.
• Repeated runs: use the recommended key when syncing into warehouses, CRMs, search indexes, vector stores, or monitoring systems.
• Schema awareness: rely on documented fields and handle newly missing optional fields gracefully.
• Run receipts: use summary and map artifacts to audit listing totals, duplicate outcomes, enrichment status, coordinate coverage, and map readiness without treating artifacts as replacement dataset rows.

Tips For Best Results

• Start with a small limit to validate record shape and optional-field coverage before scaling.
• Use one city, suburb, property type, price band, or household segment per run when clean comparison matters.
• Leave optional filters empty when the goal is broad discovery.
• Add filters gradually so changes in result scope remain easy to explain.
• Keep enrich_data for workflows that require room terms, coordinates, property features, inspections, media, or host context.
• Reuse the same input configuration for recurring monitoring and store it with the run metadata.
• Use stable identifiers rather than titles or addresses for deduplication.
• Review RUN-SUMMARY and results-map before importing a large run into production systems.

How to Run on Apify

1. Open the Actor in Apify Console.
2. Configure a supported URL or location and the property-search fields needed for your segment.
3. Set the maximum number of listings and choose whether to enrich each record.
4. Click Start and wait for the run to finish.
5. Open the dataset and inspect the first records and run artifacts.
6. Download results in JSON, CSV, Excel, or another Apify-supported format.

Agentic And API-First Usage

The actor can serve as a structured public property-data acquisition step inside larger automated workflows. An agent can define a bounded search, wait for completion, validate the dataset against the documented contract, and route records or run receipts into analysis, enrichment, alerting, search, or human-review systems.

Agent Workflow Pattern

1. Generate or select a scoped input using only the documented parameters.
2. Run the actor manually, on a schedule, or through Apify platform automation.
3. Wait for completion and read the dataset records.
4. Validate records against the Field Reference.
5. Read RUN-SUMMARY, the report, and the map when present to verify counts, duplicate outcomes, enrichment, coordinates, and artifact readiness.
6. Upsert records using source_context.source_id + record_id.
7. Trigger market analysis, enrichment, alerts, BI refreshes, vector or search indexing, lead review, or human verification.

Keep agent prompts grounded in the input schema and begin with small validation runs. Give downstream AI steps the Field Reference, recommended key, and one representative record instead of asking them to infer the contract. Treat optional listing fields as nullable and never ask an agent to invent missing rent, location, room, host, or availability values. Store run ID, input configuration, and export metadata outside the listing record when building audit trails. When context is limited for tools such as Claude, Codex, internal copilots, or property workflow agents, pass the input schema, Field Reference, idempotency key, and one output example rather than the full page.

Scheduling & Automation

Scheduling

Automated Data Collection

Schedule recurring runs to maintain comparable public listing snapshots for monitoring, dashboards, and operational review.

1. Navigate to Schedules in Apify Console.
2. Create a daily, weekly, or custom-cron schedule.
3. Configure and save the actor input parameters.
4. Enable notifications for run completion.
5. Add webhooks when downstream processing should start automatically.

Integration Options

• BI dashboards: monitor advertised weekly rents, availability, accommodation mix, enrichment coverage, and geographic distribution over time.
• Warehouses and ETL pipelines: load grouped listing JSON into historical tables and curated property datasets.
• CRM and relocation workflows: attach public listing attributes, URLs, room terms, and review status to accommodation or client records.
• Webhooks and alerts: trigger validation, ingestion, Slack, Discord, or email workflows after a scheduled run completes.
• Google Sheets or Airtable: support lightweight listing review, shortlists, and analyst annotations for bounded datasets.
• Search and vector indexes: make descriptions, locations, room features, and household context discoverable to internal applications and agents.
• MCP connectors: authorize a compatible connector in Apify, select it in the actor input, and receive the concise listing-run summary plus available dataset, report, and map links in the destination tool.

Export Formats And Downstream Use

Apify datasets can be exported for human review or consumed by automated systems.

• JSON: preserves arrays and nested objects for APIs, applications, AI agents, and data pipelines.
• CSV or Excel: supports spreadsheet workflows, stakeholder review, and lightweight analysis after deliberate flattening.
• API access: enables automated ingestion into internal systems and recurring jobs.
• BI and warehouses: supports reporting, dashboards, historical analysis, and listing monitoring.
• Search or vector indexes: supports property discovery, semantic search, retrieval workflows, and agent context.

Downstream Pipeline Guide

• Idempotency: upsert with source_context.source_id + record_id; do not use mutable titles or addresses as keys.
• Null handling: treat optional fields as nullable, especially enrichment-dependent location, room, feature, media, and host values.
• Type handling: preserve numbers, booleans, arrays, and nested objects in JSON-first destinations.
• Flattening: flatten grouped objects deliberately for CSV or Excel and retain the original JSON export for full fidelity.
• Partitioning: store run date, input segment, geography, property type, and workflow name alongside records for analysis.
• Change detection: compare repeated runs by stable key and business fields such as pricing.price, listing.listing_status, listing.available_from, and room terms.
• Quality checks: monitor saved count, duplicate count, ID availability, price coverage, enrichment status, coordinate fill, and important optional-field fill rates.
• Human review: route records with missing key fields, unusual rent values, changed status, or high-priority segments into a review queue.
• Retention: choose retention periods for raw exports, run receipts, and normalized tables according to the workflow and applicable obligations.

Performance And Coverage Expectations

No representative live performance artifact is currently available for a publishable benchmark. The following are planning estimates, not guarantees:

Planning size	Estimated duration	Coverage notes
Small run, fewer than 1,000 outputs	Approximately 3–5 minutes	Useful for validation and focused segments; enrichment may increase runtime.
Medium run, 1,000–5,000 outputs	Approximately 5–15 minutes	Broad locations and detail-rich records can require more time.
Large run, more than 5,000 outputs	Approximately 15–30 minutes	Treat as an initial planning range and validate with the chosen scope.

Execution time varies with filters, result volume, target availability, response size, enrichment depth, coordinate and map creation, and how much public information each listing exposes. Highly filtered runs can finish sooner, while broad discovery and detail enrichment may take longer. These ranges do not imply complete market coverage, fixed throughput, or guaranteed source availability; use the run summary and saved rows to evaluate each completed run.

Limitations

• Availability depends on what Flatmates.com.au publicly exposes at run time.
• Optional detail fields can be absent on sparse listings or lightweight runs.
• Very broad searches can take longer and may require a higher limit or separate market segments.
• Location precision and coordinate availability vary by listing and should not be treated as property-boundary verification.
• Source-side presentation or field changes can affect which optional values are available.
• Prices, availability, status, descriptions, room terms, and host activity are point-in-time public signals and should be verified before operational decisions.
• The actor provides structured public accommodation data, not legal, financial, investment, valuation, appraisal, brokerage, ownership-verification, or official MLS advice.

Troubleshooting

• No results returned: check location spelling, filters, accommodation category, direct URL, and whether matching public listings currently exist.
• Fewer results than expected: reduce restrictive filters, raise limit, or verify that the selected market contains enough matching records.
• Some fields are empty: optional fields depend on what each listing publicly provides and whether enrichment is enabled.
• Duplicate-looking records: compare source_context.source_id + record_id; similar titles or addresses do not necessarily identify the same listing.
• Run takes longer than expected: lower the validation limit, disable enrichment when detail fields are unnecessary, or split broad collection into smaller segments.
• Output changed: compare the current record with the Field Reference and retain a small sample for support.
• Downstream import failed: check JSON validity, nullable fields, nested objects, arrays, and whether the destination requires flattened columns.

FAQ

What data does this actor collect?

It collects public Flatmates room and rental-property listings with available identity, weekly rent, availability, location, property, room, media, household, inspection, and host context.

Which filters can I use?

Query mode supports location, weekly-rent bounds, bills included, availability date, stay length, accommodation types, household preferences, room type, furnishing, bathroom, minimum bedrooms, parking, acceptance criteria, keyword, and sort order. URL mode uses the supplied Flatmates search as the authoritative scope.

Why did I receive fewer records than my limit?

The limit is a maximum, not a promised count. The selected market may expose fewer matching public listings, or the filter combination may be narrow.

How should I choose my first limit?

Start with 5 or 10, inspect record shape and optional-field coverage, then increase the limit for the verified workflow.

What is the best unique key?

Use source_context.source_id + record_id for cross-source systems. Within this actor alone, record_id is the practical listing key.

Where are the run summary and interactive map?

Open the run's Output or key-value-store links in Apify Console. RUN-SUMMARY and RUN-SUMMARY.html are written for successful summary generation; results-map is written for enriched runs.

Can I schedule recurring runs?

Yes. Save a stable input configuration and use Apify Schedules for daily, weekly, or custom recurrence.

Can I use the output with AI agents and automated workflows?

Yes. Use the documented input schema, Field Reference, stable key, dataset records, and run receipts to keep automated steps grounded.

Can I export to CSV, Excel, or JSON?

Yes. JSON best preserves nested structures; CSV and Excel are useful after intentionally flattening the fields needed by the destination.

Does the actor collect private data or provide official property verification?

It is designed for publicly available listing information. It does not provide official MLS access, ownership verification, appraisal-grade valuation, legal conclusions, or investment advice.

What should I include when reporting an issue?

Include the redacted input, Apify run ID, expected and actual behavior, a small output sample when useful, and the downstream export format or destination if the issue is pipeline-related.

Compliance & Ethics

Responsible Data Collection

This actor collects publicly available room and rental-property listing information from Flatmates.com.au for legitimate purposes, including housing-market research and analysis, accommodation discovery and monitoring, and structured property-data workflows. Users are responsible for ensuring that collection, storage, use, and sharing comply with applicable obligations and the target site's terms. This section is informational and not legal advice.

Best Practices

• Use collected data in accordance with applicable laws, regulations, and the target site's terms.
• Respect individual privacy and personal information.
• Use data responsibly and avoid disruptive or excessive collection.
• Do not use this actor for spamming, harassment, discrimination, unlawful housing practices, or other harmful purposes.
• Follow relevant data-protection, fair-housing, consumer-protection, and sector-specific requirements where applicable.
• Review retention, access-control, and data-sharing policies before operationalizing the dataset.

Support

Ask for help through the Actor page or its Issues section. Include the redacted input, run ID, expected versus actual behavior, and an optional small output sample. For pipeline-related questions, also identify the downstream destination or export format so the issue can be reproduced and scoped accurately.