Merge pull request #141 from ZacharyHampton/feature/flexible-listing-type-and-last-update-date

Add flexible listing_type support and last_update_date field

README.md

@@ -2,11 +2,18 @@
 
 **HomeHarvest** is a real estate scraping library that extracts and formats data in the style of MLS listings.
 
+- 🚀 [HomeHarvest MCP](https://smithery.ai/server/@ZacharyHampton/homeharvest-mcp) - Easily get property data in your agent.
+- 🏠 [Zillow API](https://rapidapi.com/zachary-l1izVlvs2/api/zillow-com9) - Get Zillow data with ease.
+
 ## HomeHarvest Features
 
-- **Source**: Fetches properties directly from **Realtor.com**.
-- **Data Format**: Structures data to resemble MLS listings.
-- **Export Flexibility**: Options to save as either CSV or Excel.
+- **Source**: Fetches properties directly from **Realtor.com**
+- **Data Format**: Structures data to resemble MLS listings
+- **Export Options**: Save as CSV, Excel, or return as Pandas/Pydantic/Raw
+- **Flexible Filtering**: Filter by beds, baths, price, sqft, lot size, year built
+- **Time-Based Queries**: Search by hours, days, or specific date ranges
+- **Multiple Listing Types**: Query for_sale, for_rent, sold, pending, or all at once
+- **Sorting**: Sort results by price, date, size, or last update
 
 ![homeharvest](https://github.com/ZacharyHampton/HomeHarvest/assets/78247585/b3d5d727-e67b-4a9f-85d8-1e65fd18620a)
 
@@ -23,43 +30,67 @@ pip install -U homeharvest
 
 ```py
 from homeharvest import scrape_property
-from datetime import datetime
-
-# Generate filename based on current timestamp
-current_timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-filename = f"HomeHarvest_{current_timestamp}.csv"
 
 properties = scrape_property(
-  location="San Diego, CA",
-  listing_type="sold",  # or (for_sale, for_rent, pending)
-  past_days=30,  # sold in last 30 days - listed in last 30 days if (for_sale, for_rent)
-
-  # property_type=['single_family','multi_family'],
-  # date_from="2023-05-01", # alternative to past_days
-  # date_to="2023-05-28",
-  # foreclosure=True
-  # mls_only=True,  # only fetch MLS listings
+    location="San Diego, CA",
+    listing_type="sold",  # for_sale, for_rent, pending
+    past_days=30
 )
-print(f"Number of properties: {len(properties)}")
 
-# Export to csv
-properties.to_csv(filename, index=False)
-print(properties.head())
+properties.to_csv("results.csv", index=False)
+print(f"Found {len(properties)} properties")
 ```
 
 ### Flexible Location Formats
 ```py
-# HomeHarvest supports any of these location formats:
-properties = scrape_property(location="92104")  # Just zip code
-properties = scrape_property(location="San Diego")  # Just city  
-properties = scrape_property(location="San Diego, CA")  # City, state
-properties = scrape_property(location="San Diego, California")  # Full state name
-properties = scrape_property(location="1234 Main St, San Diego, CA 92104")  # Full address
-
-# You can also search for properties within a radius of a specific address
+# Accepts: zip code, city, "city, state", full address, etc.
 properties = scrape_property(
-    location="1234 Main St, San Diego, CA 92104",
-    radius=5.0  # 5 mile radius
+    location="San Diego, CA",  # or "92104", "San Diego", "1234 Main St, San Diego, CA 92104"
+    radius=5.0  # Optional: search within radius (miles) of address
+)
+```
+
+### Advanced Filtering Examples
+
+#### Time-Based Filtering
+```py
+from datetime import datetime, timedelta
+
+# Filter by hours or use datetime/timedelta objects
+properties = scrape_property(
+    location="Austin, TX",
+    listing_type="for_sale",
+    past_hours=24,  # or timedelta(hours=24) for Pythonic approach
+    # date_from=datetime.now() - timedelta(days=7),  # Alternative: datetime objects
+    # date_to=datetime.now(),  # Automatic hour precision detection
+)
+```
+
+#### Property Filters
+```py
+# Combine any filters: beds, baths, sqft, price, lot_sqft, year_built
+properties = scrape_property(
+    location="San Francisco, CA",
+    listing_type="for_sale",
+    beds_min=3, beds_max=5,
+    baths_min=2.0,
+    sqft_min=1500, sqft_max=3000,
+    price_min=300000, price_max=800000,
+    year_built_min=2000,
+    lot_sqft_min=5000
+)
+```
+
+#### Sorting & Listing Types
+```py
+# Sort options: list_price, list_date, sqft, beds, baths, last_update_date
+# Listing types: "for_sale", "for_rent", "sold", "pending", list, or None (all)
+properties = scrape_property(
+    location="Miami, FL",
+    listing_type=["for_sale", "pending"],  # Single string, list, or None
+    sort_by="list_price",  # Sort field
+    sort_direction="asc",  # "asc" or "desc"
+    limit=100
 )
 ```
 
@@ -134,10 +165,46 @@ Optional
 ├── past_days (integer): Number of past days to filter properties. Utilizes 'last_sold_date' for 'sold' listing types, and 'list_date' for others (for_rent, for_sale).
 │    Example: 30 (fetches properties listed/sold in the last 30 days)
 │
+├── past_hours (integer): Number of past hours to filter properties (more precise than past_days). Uses client-side filtering.
+│    Example: 24 (fetches properties from the last 24 hours)
+│    Note: Cannot be used together with past_days or date_from/date_to
+│
 ├── date_from, date_to (string): Start and end dates to filter properties listed or sold, both dates are required.
 |    (use this to get properties in chunks as there's a 10k result limit)
-│    Format for both must be "YYYY-MM-DD".
-│    Example: "2023-05-01", "2023-05-15" (fetches properties listed/sold between these dates)
+│    Accepts multiple formats with automatic precision detection:
+│    - Date strings: "YYYY-MM-DD" (day precision)
+│    - Datetime strings: "YYYY-MM-DDTHH:MM:SS" (hour precision, uses client-side filtering)
+│    - date objects: date(2025, 1, 20) (day precision)
+│    - datetime objects: datetime(2025, 1, 20, 9, 0) (hour precision)
+│    Examples:
+│      Day precision: "2023-05-01", "2023-05-15"
+│      Hour precision: "2025-01-20T09:00:00", "2025-01-20T17:00:00"
+│
+├── beds_min, beds_max (integer): Filter by number of bedrooms
+│    Example: beds_min=2, beds_max=4 (2-4 bedrooms)
+│
+├── baths_min, baths_max (float): Filter by number of bathrooms
+│    Example: baths_min=2.0, baths_max=3.5 (2-3.5 bathrooms)
+│
+├── sqft_min, sqft_max (integer): Filter by square footage
+│    Example: sqft_min=1000, sqft_max=2500 (1,000-2,500 sq ft)
+│
+├── price_min, price_max (integer): Filter by listing price
+│    Example: price_min=200000, price_max=500000 ($200k-$500k)
+│
+├── lot_sqft_min, lot_sqft_max (integer): Filter by lot size in square feet
+│    Example: lot_sqft_min=5000, lot_sqft_max=10000 (5,000-10,000 sq ft lot)
+│
+├── year_built_min, year_built_max (integer): Filter by year built
+│    Example: year_built_min=2000, year_built_max=2024 (built between 2000-2024)
+│
+├── sort_by (string): Sort results by field
+│    Options: 'list_date', 'sold_date', 'list_price', 'sqft', 'beds', 'baths'
+│    Example: sort_by='list_price'
+│
+├── sort_direction (string): Sort direction, default is 'desc'
+│    Options: 'asc' (ascending), 'desc' (descending)
+│    Example: sort_direction='asc' (cheapest first)
 │
 ├── mls_only (True/False): If set, fetches only MLS listings (mainly applicable to 'sold' listings)
 │
@@ -149,7 +216,9 @@ Optional
 │
 ├── exclude_pending (True/False): If set, excludes 'pending' properties from the 'for_sale' results unless listing_type is 'pending'
 │
-└── limit (integer): Limit the number of properties to fetch. Max & default is 10000.
+├── limit (integer): Limit the number of properties to fetch. Max & default is 10000.
+│
+└── offset (integer): Starting position for pagination within the 10k limit. Use with limit to fetch results in chunks.
 ```
 
 ### Property Schema
@@ -191,10 +260,11 @@ Property
 │ ├── list_price
 │ ├── list_price_min
 │ ├── list_price_max
-│ ├── list_date  # datetime
-│ ├── pending_date  # datetime
+│ ├── list_date  # datetime (full timestamp: YYYY-MM-DD HH:MM:SS)
+│ ├── pending_date  # datetime (full timestamp: YYYY-MM-DD HH:MM:SS)
 │ ├── sold_price
-│ ├── last_sold_date  # datetime
+│ ├── last_sold_date  # datetime (full timestamp: YYYY-MM-DD HH:MM:SS)
+│ ├── last_status_change_date  # datetime (full timestamp: YYYY-MM-DD HH:MM:SS)
 │ ├── last_sold_price
 │ ├── price_per_sqft
 │ ├── new_construction

homeharvest/__init__.py

@@ -1,62 +1,173 @@
 import warnings
 import pandas as pd
+from datetime import datetime, timedelta, date
 from .core.scrapers import ScraperInput
-from .utils import process_result, ordered_properties, validate_input, validate_dates, validate_limit
+from .utils import (
+    process_result, ordered_properties, validate_input, validate_dates, validate_limit,
+    validate_offset, validate_datetime, validate_filters, validate_sort, validate_last_update_filters,
+    convert_to_datetime_string, extract_timedelta_hours, extract_timedelta_days, detect_precision_and_convert
+)
 from .core.scrapers.realtor import RealtorScraper
 from .core.scrapers.models import ListingType, SearchPropertyType, ReturnType, Property
 from typing import Union, Optional, List
 
 def scrape_property(
     location: str,
-    listing_type: str = "for_sale",
+    listing_type: str | list[str] | None = None,
     return_type: str = "pandas",
     property_type: Optional[List[str]] = None,
     radius: float = None,
     mls_only: bool = False,
-    past_days: int = None,
+    past_days: int | timedelta = None,
     proxy: str = None,
-    date_from: str = None,  #: TODO: Switch to one parameter, Date, with date_from and date_to, pydantic validation
-    date_to: str = None,
+    date_from: datetime | date | str = None,
+    date_to: datetime | date | str = None,
     foreclosure: bool = None,
     extra_property_data: bool = True,
     exclude_pending: bool = False,
-    limit: int = 10000
+    limit: int = 10000,
+    offset: int = 0,
+    # New date/time filtering parameters
+    past_hours: int | timedelta = None,
+    # New last_update_date filtering parameters
+    updated_since: datetime | str = None,
+    updated_in_past_hours: int | timedelta = None,
+    # New property filtering parameters
+    beds_min: int = None,
+    beds_max: int = None,
+    baths_min: float = None,
+    baths_max: float = None,
+    sqft_min: int = None,
+    sqft_max: int = None,
+    price_min: int = None,
+    price_max: int = None,
+    lot_sqft_min: int = None,
+    lot_sqft_max: int = None,
+    year_built_min: int = None,
+    year_built_max: int = None,
+    # New sorting parameters
+    sort_by: str = None,
+    sort_direction: str = "desc",
 ) -> Union[pd.DataFrame, list[dict], list[Property]]:
     """
     Scrape properties from Realtor.com based on a given location and listing type.
+
     :param location: Location to search (e.g. "Dallas, TX", "85281", "2530 Al Lipscomb Way")
-    :param listing_type: Listing Type (for_sale, for_rent, sold, pending)
+    :param listing_type: Listing Type - can be a string, list of strings, or None.
+        Options: for_sale, for_rent, sold, pending, off_market, new_community, other, ready_to_build
+        Examples: "for_sale", ["for_sale", "pending"], None (returns all types)
     :param return_type: Return type (pandas, pydantic, raw)
     :param property_type: Property Type (single_family, multi_family, condos, condo_townhome_rowhome_coop, condo_townhome, townhomes, duplex_triplex, farm, land, mobile)
     :param radius: Get properties within _ (e.g. 1.0) miles. Only applicable for individual addresses.
     :param mls_only: If set, fetches only listings with MLS IDs.
     :param proxy: Proxy to use for scraping
     :param past_days: Get properties sold or listed (dependent on your listing_type) in the last _ days.
-    :param date_from, date_to: Get properties sold or listed (dependent on your listing_type) between these dates. format: 2021-01-28
+        - PENDING: Filters by pending_date. Contingent properties without pending_date are included.
+        - SOLD: Filters by sold_date (when property was sold)
+        - FOR_SALE/FOR_RENT: Filters by list_date (when property was listed)
+    :param date_from, date_to: Get properties sold or listed (dependent on your listing_type) between these dates.
+        Accepts multiple formats for flexible precision:
+        - Date strings: "2025-01-20" (day-level precision)
+        - Datetime strings: "2025-01-20T14:30:00" (hour-level precision)
+        - date objects: date(2025, 1, 20) (day-level precision)
+        - datetime objects: datetime(2025, 1, 20, 14, 30) (hour-level precision)
+        The precision is automatically detected based on the input format.
     :param foreclosure: If set, fetches only foreclosure listings.
     :param extra_property_data: Increases requests by O(n). If set, this fetches additional property data (e.g. agent, broker, property evaluations etc.)
     :param exclude_pending: If true, this excludes pending or contingent properties from the results, unless listing type is pending.
     :param limit: Limit the number of results returned. Maximum is 10,000.
+    :param offset: Starting position for pagination within the 10k limit (offset + limit cannot exceed 10,000). Use with limit to fetch results in chunks (e.g., offset=200, limit=200 fetches results 200-399). Should be a multiple of 200 (page size) for optimal performance. Default is 0. Note: Cannot be used to bypass the 10k API limit - use date ranges (date_from/date_to) to narrow searches and fetch more data.
+
+    New parameters:
+    :param past_hours: Get properties in the last _ hours (requires client-side filtering). Accepts int or timedelta.
+    :param updated_since: Filter by last_update_date (when property was last updated). Accepts datetime object or ISO 8601 string (client-side filtering)
+    :param updated_in_past_hours: Filter by properties updated in the last _ hours. Accepts int or timedelta (client-side filtering)
+    :param beds_min, beds_max: Filter by number of bedrooms
+    :param baths_min, baths_max: Filter by number of bathrooms
+    :param sqft_min, sqft_max: Filter by square footage
+    :param price_min, price_max: Filter by listing price
+    :param lot_sqft_min, lot_sqft_max: Filter by lot size
+    :param year_built_min, year_built_max: Filter by year built
+    :param sort_by: Sort results by field (list_date, sold_date, list_price, sqft, beds, baths, last_update_date)
+    :param sort_direction: Sort direction (asc, desc)
+
+    Note: past_days and past_hours also accept timedelta objects for more Pythonic usage.
     """
     validate_input(listing_type)
-    validate_dates(date_from, date_to)
     validate_limit(limit)
+    validate_offset(offset, limit)
+    validate_filters(
+        beds_min, beds_max, baths_min, baths_max, sqft_min, sqft_max,
+        price_min, price_max, lot_sqft_min, lot_sqft_max, year_built_min, year_built_max
+    )
+    validate_sort(sort_by, sort_direction)
+
+    # Validate new last_update_date filtering parameters
+    validate_last_update_filters(
+        convert_to_datetime_string(updated_since),
+        extract_timedelta_hours(updated_in_past_hours)
+    )
+
+    # Convert listing_type to appropriate format
+    if listing_type is None:
+        converted_listing_type = None
+    elif isinstance(listing_type, list):
+        converted_listing_type = [ListingType(lt.upper()) for lt in listing_type]
+    else:
+        converted_listing_type = ListingType(listing_type.upper())
+
+    # Convert date_from/date_to with precision detection
+    converted_date_from, date_from_precision = detect_precision_and_convert(date_from)
+    converted_date_to, date_to_precision = detect_precision_and_convert(date_to)
+
+    # Validate converted dates
+    validate_dates(converted_date_from, converted_date_to)
+
+    # Convert datetime/timedelta objects to appropriate formats
+    converted_past_days = extract_timedelta_days(past_days)
+    converted_past_hours = extract_timedelta_hours(past_hours)
+    converted_updated_since = convert_to_datetime_string(updated_since)
+    converted_updated_in_past_hours = extract_timedelta_hours(updated_in_past_hours)
 
     scraper_input = ScraperInput(
         location=location,
-        listing_type=ListingType(listing_type.upper()),
+        listing_type=converted_listing_type,
         return_type=ReturnType(return_type.lower()),
         property_type=[SearchPropertyType[prop.upper()] for prop in property_type] if property_type else None,
         proxy=proxy,
         radius=radius,
         mls_only=mls_only,
-        last_x_days=past_days,
-        date_from=date_from,
-        date_to=date_to,
+        last_x_days=converted_past_days,
+        date_from=converted_date_from,
+        date_to=converted_date_to,
+        date_from_precision=date_from_precision,
+        date_to_precision=date_to_precision,
         foreclosure=foreclosure,
         extra_property_data=extra_property_data,
         exclude_pending=exclude_pending,
         limit=limit,
+        offset=offset,
+        # New date/time filtering
+        past_hours=converted_past_hours,
+        # New last_update_date filtering
+        updated_since=converted_updated_since,
+        updated_in_past_hours=converted_updated_in_past_hours,
+        # New property filtering
+        beds_min=beds_min,
+        beds_max=beds_max,
+        baths_min=baths_min,
+        baths_max=baths_max,
+        sqft_min=sqft_min,
+        sqft_max=sqft_max,
+        price_min=price_min,
+        price_max=price_max,
+        lot_sqft_min=lot_sqft_min,
+        lot_sqft_max=lot_sqft_max,
+        year_built_min=year_built_min,
+        year_built_max=year_built_max,
+        # New sorting
+        sort_by=sort_by,
+        sort_direction=sort_direction,
     )
 
     site = RealtorScraper(scraper_input)

homeharvest/cli.py

@@ -1,85 +0,0 @@
-import argparse
-import datetime
-from homeharvest import scrape_property
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Home Harvest Property Scraper")
-    parser.add_argument("location", type=str, help="Location to scrape (e.g., San Francisco, CA)")
-
-    parser.add_argument(
-        "-l",
-        "--listing_type",
-        type=str,
-        default="for_sale",
-        choices=["for_sale", "for_rent", "sold", "pending"],
-        help="Listing type to scrape",
-    )
-
-    parser.add_argument(
-        "-o",
-        "--output",
-        type=str,
-        default="excel",
-        choices=["excel", "csv"],
-        help="Output format",
-    )
-
-    parser.add_argument(
-        "-f",
-        "--filename",
-        type=str,
-        default=None,
-        help="Name of the output file (without extension)",
-    )
-
-    parser.add_argument("-p", "--proxy", type=str, default=None, help="Proxy to use for scraping")
-    parser.add_argument(
-        "-d",
-        "--days",
-        type=int,
-        default=None,
-        help="Sold/listed in last _ days filter.",
-    )
-
-    parser.add_argument(
-        "-r",
-        "--radius",
-        type=float,
-        default=None,
-        help="Get comparable properties within _ (eg. 0.0) miles. Only applicable for individual addresses.",
-    )
-    parser.add_argument(
-        "-m",
-        "--mls_only",
-        action="store_true",
-        help="If set, fetches only MLS listings.",
-    )
-
-    args = parser.parse_args()
-
-    result = scrape_property(
-        args.location,
-        args.listing_type,
-        radius=args.radius,
-        proxy=args.proxy,
-        mls_only=args.mls_only,
-        past_days=args.days,
-    )
-
-    if not args.filename:
-        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-        args.filename = f"HomeHarvest_{timestamp}"
-
-    if args.output == "excel":
-        output_filename = f"{args.filename}.xlsx"
-        result.to_excel(output_filename, index=False)
-        print(f"Excel file saved as {output_filename}")
-    elif args.output == "csv":
-        output_filename = f"{args.filename}.csv"
-        result.to_csv(output_filename, index=False)
-        print(f"CSV file saved as {output_filename}")
-
-
-if __name__ == "__main__":
-    main()

homeharvest/core/scrapers/__init__.py

@@ -13,7 +13,7 @@ from pydantic import BaseModel
 
 class ScraperInput(BaseModel):
     location: str
-    listing_type: ListingType
+    listing_type: ListingType | list[ListingType] | None
     property_type: list[SearchPropertyType] | None = None
     radius: float | None = None
     mls_only: bool | None = False
@@ -21,12 +21,40 @@ class ScraperInput(BaseModel):
     last_x_days: int | None = None
     date_from: str | None = None
     date_to: str | None = None
+    date_from_precision: str | None = None  # "day" or "hour"
+    date_to_precision: str | None = None    # "day" or "hour"
     foreclosure: bool | None = False
     extra_property_data: bool | None = True
     exclude_pending: bool | None = False
     limit: int = 10000
+    offset: int = 0
     return_type: ReturnType = ReturnType.pandas
 
+    # New date/time filtering parameters
+    past_hours: int | None = None
+
+    # New last_update_date filtering parameters
+    updated_since: str | None = None
+    updated_in_past_hours: int | None = None
+
+    # New property filtering parameters
+    beds_min: int | None = None
+    beds_max: int | None = None
+    baths_min: float | None = None
+    baths_max: float | None = None
+    sqft_min: int | None = None
+    sqft_max: int | None = None
+    price_min: int | None = None
+    price_max: int | None = None
+    lot_sqft_min: int | None = None
+    lot_sqft_max: int | None = None
+    year_built_min: int | None = None
+    year_built_max: int | None = None
+
+    # New sorting parameters
+    sort_by: str | None = None
+    sort_direction: str = "desc"
+
 
 class Scraper:
     session = None
@@ -79,12 +107,40 @@ class Scraper:
         self.mls_only = scraper_input.mls_only
         self.date_from = scraper_input.date_from
         self.date_to = scraper_input.date_to
+        self.date_from_precision = scraper_input.date_from_precision
+        self.date_to_precision = scraper_input.date_to_precision
         self.foreclosure = scraper_input.foreclosure
         self.extra_property_data = scraper_input.extra_property_data
         self.exclude_pending = scraper_input.exclude_pending
         self.limit = scraper_input.limit
+        self.offset = scraper_input.offset
         self.return_type = scraper_input.return_type
 
+        # New date/time filtering
+        self.past_hours = scraper_input.past_hours
+
+        # New last_update_date filtering
+        self.updated_since = scraper_input.updated_since
+        self.updated_in_past_hours = scraper_input.updated_in_past_hours
+
+        # New property filtering
+        self.beds_min = scraper_input.beds_min
+        self.beds_max = scraper_input.beds_max
+        self.baths_min = scraper_input.baths_min
+        self.baths_max = scraper_input.baths_max
+        self.sqft_min = scraper_input.sqft_min
+        self.sqft_max = scraper_input.sqft_max
+        self.price_min = scraper_input.price_min
+        self.price_max = scraper_input.price_max
+        self.lot_sqft_min = scraper_input.lot_sqft_min
+        self.lot_sqft_max = scraper_input.lot_sqft_max
+        self.year_built_min = scraper_input.year_built_min
+        self.year_built_max = scraper_input.year_built_max
+
+        # New sorting
+        self.sort_by = scraper_input.sort_by
+        self.sort_direction = scraper_input.sort_direction
+
     def search(self) -> list[Union[Property | dict]]: ...
 
     @staticmethod

homeharvest/core/scrapers/models.py

@@ -43,6 +43,10 @@ class ListingType(Enum):
     FOR_RENT = "FOR_RENT"
     PENDING = "PENDING"
     SOLD = "SOLD"
+    OFF_MARKET = "OFF_MARKET"
+    NEW_COMMUNITY = "NEW_COMMUNITY"
+    OTHER = "OTHER"
+    READY_TO_BUILD = "READY_TO_BUILD"
 
 
 class PropertyType(Enum):
@@ -192,6 +196,8 @@ class Property(BaseModel):
     list_date: datetime | None = Field(None, description="The time this Home entered Move system")
     pending_date: datetime | None = Field(None, description="The date listing went into pending state")
     last_sold_date: datetime | None = Field(None, description="Last time the Home was sold")
+    last_status_change_date: datetime | None = Field(None, description="Last time the status of the listing changed")
+    last_update_date: datetime | None = Field(None, description="Last time the home was updated")
     prc_sqft: int | None = None
     new_construction: bool | None = Field(None, description="Search for new construction homes")
     hoa_fee: int | None = Field(None, description="Search for homes where HOA fee is known and falls within specified range")

homeharvest/core/scrapers/realtor/__init__.py

@@ -46,9 +46,17 @@ class RealtorScraper(Scraper):
         super().__init__(scraper_input)
 
     def handle_location(self):
+        # Get client_id from listing_type
+        if self.listing_type is None:
+            client_id = "for-sale"
+        elif isinstance(self.listing_type, list):
+            client_id = self.listing_type[0].value.lower().replace("_", "-") if self.listing_type else "for-sale"
+        else:
+            client_id = self.listing_type.value.lower().replace("_", "-")
+
         params = {
             "input": self.location,
-            "client_id": self.listing_type.value.lower().replace("_", "-"),
+            "client_id": client_id,
             "limit": "1",
             "area_types": "city,state,county,postal_code,address,street,neighborhood,school,school_district,university,park",
         }
@@ -132,33 +140,175 @@ class RealtorScraper(Scraper):
         """
 
         date_param = ""
-        if self.listing_type == ListingType.SOLD:
-            if self.date_from and self.date_to:
-                date_param = f'sold_date: {{ min: "{self.date_from}", max: "{self.date_to}" }}'
-            elif self.last_x_days:
-                date_param = f'sold_date: {{ min: "$today-{self.last_x_days}D" }}'
+
+        # Determine date field based on listing type
+        # Convert listing_type to list for uniform handling
+        if self.listing_type is None:
+            listing_types = []
+            date_field = None  # When no listing_type is specified, skip date filtering
+        elif isinstance(self.listing_type, list):
+            listing_types = self.listing_type
+            # For multiple types, we'll use a general date field or skip
+            date_field = None  # Skip date filtering for mixed types
         else:
-            if self.date_from and self.date_to:
-                date_param = f'list_date: {{ min: "{self.date_from}", max: "{self.date_to}" }}'
+            listing_types = [self.listing_type]
+            # Determine date field for single type
+            if self.listing_type == ListingType.SOLD:
+                date_field = "sold_date"
+            elif self.listing_type in [ListingType.FOR_SALE, ListingType.FOR_RENT]:
+                date_field = "list_date"
+            else:  # PENDING or other types
+                # Skip server-side date filtering for PENDING as both pending_date and contract_date
+                # filters are broken in the API. Client-side filtering will be applied later.
+                date_field = None
+
+        # Build date parameter (expand to full days if hour-based filtering is used)
+        if date_field:
+            # Check if we have hour precision (need to extract date part for API, then filter client-side)
+            has_hour_precision = (self.date_from_precision == "hour" or self.date_to_precision == "hour")
+
+            if has_hour_precision and (self.date_from or self.date_to):
+                # Hour-based datetime filtering: extract date parts for API, client-side filter by hours
+                from datetime import datetime
+
+                min_date = None
+                max_date = None
+
+                if self.date_from:
+                    try:
+                        dt_from = datetime.fromisoformat(self.date_from.replace('Z', '+00:00'))
+                        min_date = dt_from.strftime("%Y-%m-%d")
+                    except (ValueError, AttributeError):
+                        pass
+
+                if self.date_to:
+                    try:
+                        dt_to = datetime.fromisoformat(self.date_to.replace('Z', '+00:00'))
+                        max_date = dt_to.strftime("%Y-%m-%d")
+                    except (ValueError, AttributeError):
+                        pass
+
+                if min_date and max_date:
+                    date_param = f'{date_field}: {{ min: "{min_date}", max: "{max_date}" }}'
+                elif min_date:
+                    date_param = f'{date_field}: {{ min: "{min_date}" }}'
+                elif max_date:
+                    date_param = f'{date_field}: {{ max: "{max_date}" }}'
+
+            elif self.past_hours:
+                # Query API for past N days (minimum 1 day), client-side filter by hours
+                days = max(1, int(self.past_hours / 24) + 1)  # Round up to cover the full period
+                date_param = f'{date_field}: {{ min: "$today-{days}D" }}'
+
+            elif self.date_from and self.date_to:
+                date_param = f'{date_field}: {{ min: "{self.date_from}", max: "{self.date_to}" }}'
             elif self.last_x_days:
-                date_param = f'list_date: {{ min: "$today-{self.last_x_days}D" }}'
+                date_param = f'{date_field}: {{ min: "$today-{self.last_x_days}D" }}'
 
         property_type_param = ""
         if self.property_type:
             property_types = [pt.value for pt in self.property_type]
             property_type_param = f"type: {json.dumps(property_types)}"
 
-        sort_param = (
-            "sort: [{ field: sold_date, direction: desc }]"
-            if self.listing_type == ListingType.SOLD
-            else ""  #: "sort: [{ field: list_date, direction: desc }]"  #: prioritize normal fractal sort from realtor
-        )
+        # Build property filter parameters
+        property_filters = []
 
+        if self.beds_min is not None or self.beds_max is not None:
+            beds_filter = "beds: {"
+            if self.beds_min is not None:
+                beds_filter += f" min: {self.beds_min}"
+            if self.beds_max is not None:
+                beds_filter += f" max: {self.beds_max}"
+            beds_filter += " }"
+            property_filters.append(beds_filter)
+
+        if self.baths_min is not None or self.baths_max is not None:
+            baths_filter = "baths: {"
+            if self.baths_min is not None:
+                baths_filter += f" min: {self.baths_min}"
+            if self.baths_max is not None:
+                baths_filter += f" max: {self.baths_max}"
+            baths_filter += " }"
+            property_filters.append(baths_filter)
+
+        if self.sqft_min is not None or self.sqft_max is not None:
+            sqft_filter = "sqft: {"
+            if self.sqft_min is not None:
+                sqft_filter += f" min: {self.sqft_min}"
+            if self.sqft_max is not None:
+                sqft_filter += f" max: {self.sqft_max}"
+            sqft_filter += " }"
+            property_filters.append(sqft_filter)
+
+        if self.price_min is not None or self.price_max is not None:
+            price_filter = "list_price: {"
+            if self.price_min is not None:
+                price_filter += f" min: {self.price_min}"
+            if self.price_max is not None:
+                price_filter += f" max: {self.price_max}"
+            price_filter += " }"
+            property_filters.append(price_filter)
+
+        if self.lot_sqft_min is not None or self.lot_sqft_max is not None:
+            lot_sqft_filter = "lot_sqft: {"
+            if self.lot_sqft_min is not None:
+                lot_sqft_filter += f" min: {self.lot_sqft_min}"
+            if self.lot_sqft_max is not None:
+                lot_sqft_filter += f" max: {self.lot_sqft_max}"
+            lot_sqft_filter += " }"
+            property_filters.append(lot_sqft_filter)
+
+        if self.year_built_min is not None or self.year_built_max is not None:
+            year_built_filter = "year_built: {"
+            if self.year_built_min is not None:
+                year_built_filter += f" min: {self.year_built_min}"
+            if self.year_built_max is not None:
+                year_built_filter += f" max: {self.year_built_max}"
+            year_built_filter += " }"
+            property_filters.append(year_built_filter)
+
+        property_filters_param = "\n".join(property_filters)
+
+        # Build sort parameter
+        if self.sort_by:
+            sort_param = f"sort: [{{ field: {self.sort_by}, direction: {self.sort_direction} }}]"
+        elif isinstance(self.listing_type, ListingType) and self.listing_type == ListingType.SOLD:
+            sort_param = "sort: [{ field: sold_date, direction: desc }]"
+        else:
+            sort_param = ""  #: prioritize normal fractal sort from realtor
+
+        # Handle PENDING with or_filters (applies if PENDING is in the list or is the single type)
+        has_pending = ListingType.PENDING in listing_types
         pending_or_contingent_param = (
-            "or_filters: { contingent: true, pending: true }" if self.listing_type == ListingType.PENDING else ""
+            "or_filters: { contingent: true, pending: true }" if has_pending else ""
         )
 
-        listing_type = ListingType.FOR_SALE if self.listing_type == ListingType.PENDING else self.listing_type
+        # Build bucket parameter (only use fractal sort if no custom sort is specified)
+        bucket_param = ""
+        if not self.sort_by:
+            bucket_param = 'bucket: { sort: "fractal_v1.1.3_fr" }'
+
+        # Build status parameter
+        # For PENDING, we need to query as FOR_SALE with or_filters for pending/contingent
+        status_types = []
+        for lt in listing_types:
+            if lt == ListingType.PENDING:
+                if ListingType.FOR_SALE not in status_types:
+                    status_types.append(ListingType.FOR_SALE)
+            else:
+                if lt not in status_types:
+                    status_types.append(lt)
+
+        # Build status parameter string
+        if status_types:
+            status_values = [st.value.lower() for st in status_types]
+            if len(status_values) == 1:
+                status_param = f"status: {status_values[0]}"
+            else:
+                status_param = f"status: [{', '.join(status_values)}]"
+        else:
+            status_param = ""  # No status parameter means return all types
+
         is_foreclosure = ""
 
         if variables.get("foreclosure") is True:
@@ -179,7 +329,8 @@ class RealtorScraper(Scraper):
                                     coordinates: $coordinates
                                     radius: $radius
                                 }
-                                status: %s
+                                %s
+                                %s
                                 %s
                                 %s
                                 %s
@@ -190,9 +341,10 @@ class RealtorScraper(Scraper):
                     ) %s
                 }""" % (
                 is_foreclosure,
-                listing_type.value.lower(),
+                status_param,
                 date_param,
                 property_type_param,
+                property_filters_param,
                 pending_or_contingent_param,
                 sort_param,
                 GENERAL_RESULTS_QUERY,
@@ -212,22 +364,25 @@ class RealtorScraper(Scraper):
                                         county: $county
                                         postal_code: $postal_code
                                         state_code: $state_code
-                                        status: %s
+                                        %s
+                                        %s
                                         %s
                                         %s
                                         %s
                                     }
-                                    bucket: { sort: "fractal_v1.1.3_fr" }
+                                    %s
                                     %s
                                     limit: 200
                                     offset: $offset
                                 ) %s
                             }""" % (
                 is_foreclosure,
-                listing_type.value.lower(),
+                status_param,
                 date_param,
                 property_type_param,
+                property_filters_param,
                 pending_or_contingent_param,
+                bucket_param,
                 sort_param,
                 GENERAL_RESULTS_QUERY,
             )
@@ -294,13 +449,23 @@ class RealtorScraper(Scraper):
 
         if self.return_type != ReturnType.raw:
             with ThreadPoolExecutor(max_workers=self.NUM_PROPERTY_WORKERS) as executor:
-                futures = [executor.submit(process_property, result, self.mls_only, self.extra_property_data, 
-                                         self.exclude_pending, self.listing_type, get_key, process_extra_property_details) for result in properties_list]
+                # Store futures with their indices to maintain sort order
+                futures_with_indices = [
+                    (i, executor.submit(process_property, result, self.mls_only, self.extra_property_data,
+                                       self.exclude_pending, self.listing_type, get_key, process_extra_property_details))
+                    for i, result in enumerate(properties_list)
+                ]
 
-                for future in as_completed(futures):
+                # Collect results and sort by index to preserve API sort order
+                results = []
+                for idx, future in futures_with_indices:
                     result = future.result()
                     if result:
-                        properties.append(result)
+                        results.append((idx, result))
+
+                # Sort by index and extract properties in correct order
+                results.sort(key=lambda x: x[0])
+                properties = [result for idx, result in results]
         else:
             properties = properties_list
 
@@ -317,7 +482,7 @@ class RealtorScraper(Scraper):
         location_type = location_info["area_type"]
 
         search_variables = {
-            "offset": 0,
+            "offset": self.offset,
         }
 
         search_type = (
@@ -362,24 +527,418 @@ class RealtorScraper(Scraper):
         homes = result["properties"]
 
         with ThreadPoolExecutor() as executor:
-            futures = [
-                executor.submit(
+            # Store futures with their offsets to maintain proper sort order
+            # Start from offset + page_size and go up to offset + limit
+            futures_with_offsets = [
+                (i, executor.submit(
                     self.general_search,
                     variables=search_variables | {"offset": i},
                     search_type=search_type,
-                )
+                ))
                 for i in range(
-                    self.DEFAULT_PAGE_SIZE,
-                    min(total, self.limit),
+                    self.offset + self.DEFAULT_PAGE_SIZE,
+                    min(total, self.offset + self.limit),
                     self.DEFAULT_PAGE_SIZE,
                 )
             ]
 
-            for future in as_completed(futures):
-                homes.extend(future.result()["properties"])
+            # Collect results and sort by offset to preserve API sort order across pages
+            results = []
+            for offset, future in futures_with_offsets:
+                results.append((offset, future.result()["properties"]))
+
+            # Sort by offset and concatenate in correct order
+            results.sort(key=lambda x: x[0])
+            for offset, properties in results:
+                homes.extend(properties)
+
+        # Apply client-side hour-based filtering if needed
+        # (API only supports day-level filtering, so we post-filter for hour precision)
+        has_hour_precision = (self.date_from_precision == "hour" or self.date_to_precision == "hour")
+        if self.past_hours or has_hour_precision:
+            homes = self._apply_hour_based_date_filter(homes)
+        # Apply client-side date filtering for PENDING properties
+        # (server-side filters are broken in the API)
+        elif self.listing_type == ListingType.PENDING and (self.last_x_days or self.date_from):
+            homes = self._apply_pending_date_filter(homes)
+
+        # Apply client-side filtering by last_update_date if specified
+        if self.updated_since or self.updated_in_past_hours:
+            homes = self._apply_last_update_date_filter(homes)
+
+        # Apply client-side sort to ensure results are properly ordered
+        # This is necessary after filtering and to guarantee sort order across page boundaries
+        if self.sort_by:
+            homes = self._apply_sort(homes)
+
+        # Apply raw data filters (exclude_pending and mls_only) for raw return type
+        # These filters are normally applied in process_property() but are bypassed for raw data
+        if self.return_type == ReturnType.raw:
+            homes = self._apply_raw_data_filters(homes)
 
         return homes
 
+    def _apply_hour_based_date_filter(self, homes):
+        """Apply client-side hour-based date filtering for all listing types.
+
+        This is used when past_hours or date_from/date_to have hour precision,
+        since the API only supports day-level filtering.
+        """
+        if not homes:
+            return homes
+
+        from datetime import datetime, timedelta
+
+        # Determine date range with hour precision
+        date_range = None
+
+        if self.past_hours:
+            cutoff_datetime = datetime.now() - timedelta(hours=self.past_hours)
+            date_range = {'type': 'since', 'date': cutoff_datetime}
+        elif self.date_from or self.date_to:
+            try:
+                from_datetime = None
+                to_datetime = None
+
+                if self.date_from:
+                    from_datetime_str = self.date_from.replace('Z', '+00:00') if self.date_from.endswith('Z') else self.date_from
+                    from_datetime = datetime.fromisoformat(from_datetime_str).replace(tzinfo=None)
+
+                if self.date_to:
+                    to_datetime_str = self.date_to.replace('Z', '+00:00') if self.date_to.endswith('Z') else self.date_to
+                    to_datetime = datetime.fromisoformat(to_datetime_str).replace(tzinfo=None)
+
+                if from_datetime and to_datetime:
+                    date_range = {'type': 'range', 'from_date': from_datetime, 'to_date': to_datetime}
+                elif from_datetime:
+                    date_range = {'type': 'since', 'date': from_datetime}
+                elif to_datetime:
+                    date_range = {'type': 'until', 'date': to_datetime}
+            except (ValueError, AttributeError):
+                return homes  # If parsing fails, return unfiltered
+
+        if not date_range:
+            return homes
+
+        # Determine which date field to use based on listing type
+        date_field_name = self._get_date_field_for_listing_type()
+
+        filtered_homes = []
+
+        for home in homes:
+            # Extract the appropriate date for this property
+            property_date = self._extract_date_from_home(home, date_field_name)
+
+            # Handle properties without dates
+            if property_date is None:
+                # For PENDING, include contingent properties without pending_date
+                if self.listing_type == ListingType.PENDING and self._is_contingent(home):
+                    filtered_homes.append(home)
+                continue
+
+            # Check if property date falls within the specified range
+            if self._is_datetime_in_range(property_date, date_range):
+                filtered_homes.append(home)
+
+        return filtered_homes
+
+    def _get_date_field_for_listing_type(self):
+        """Get the appropriate date field name for the current listing type."""
+        if self.listing_type == ListingType.SOLD:
+            return 'last_sold_date'
+        elif self.listing_type == ListingType.PENDING:
+            return 'pending_date'
+        else:  # FOR_SALE or FOR_RENT
+            return 'list_date'
+
+    def _extract_date_from_home(self, home, date_field_name):
+        """Extract a date field from a home (handles both dict and Property object).
+
+        Falls back to last_status_change_date if the primary date field is not available,
+        providing more precise filtering for PENDING/SOLD properties.
+        """
+        if isinstance(home, dict):
+            date_value = home.get(date_field_name)
+        else:
+            date_value = getattr(home, date_field_name, None)
+
+        if date_value:
+            return self._parse_date_value(date_value)
+
+        # Fallback to last_status_change_date if primary date field is missing
+        # This is useful for PENDING/SOLD properties where the specific date might be unavailable
+        if isinstance(home, dict):
+            fallback_date = home.get('last_status_change_date')
+        else:
+            fallback_date = getattr(home, 'last_status_change_date', None)
+
+        if fallback_date:
+            return self._parse_date_value(fallback_date)
+
+        return None
+
+    def _is_datetime_in_range(self, date_obj, date_range):
+        """Check if a datetime object falls within the specified date range (with hour precision)."""
+        if date_range['type'] == 'since':
+            return date_obj >= date_range['date']
+        elif date_range['type'] == 'until':
+            return date_obj <= date_range['date']
+        elif date_range['type'] == 'range':
+            return date_range['from_date'] <= date_obj <= date_range['to_date']
+        return False
+
+    def _apply_pending_date_filter(self, homes):
+        """Apply client-side date filtering for PENDING properties based on pending_date field.
+        For contingent properties without pending_date, tries fallback date fields."""
+        if not homes:
+            return homes
+            
+        from datetime import datetime, timedelta
+        
+        # Determine date range for filtering
+        date_range = self._get_date_range()
+        if not date_range:
+            return homes
+            
+        filtered_homes = []
+        
+        for home in homes:
+            # Extract the best available date for this property
+            property_date = self._extract_property_date_for_filtering(home)
+            
+            # Handle properties without dates (include contingent properties)
+            if property_date is None:
+                if self._is_contingent(home):
+                    filtered_homes.append(home)  # Include contingent without date filter
+                continue
+            
+            # Check if property date falls within the specified range
+            if self._is_date_in_range(property_date, date_range):
+                filtered_homes.append(home)
+                
+        return filtered_homes
+    
+    def _get_pending_date(self, home):
+        """Extract pending_date from a home property (handles both dict and Property object)."""
+        if isinstance(home, dict):
+            return home.get('pending_date')
+        else:
+            # Assume it's a Property object
+            return getattr(home, 'pending_date', None)
+    
+    
+    def _is_contingent(self, home):
+        """Check if a property is contingent."""
+        if isinstance(home, dict):
+            flags = home.get('flags', {})
+            return flags.get('is_contingent', False)
+        else:
+            # Property object - check flags attribute
+            if hasattr(home, 'flags') and home.flags:
+                return getattr(home.flags, 'is_contingent', False)
+            return False
+
+    def _apply_last_update_date_filter(self, homes):
+        """Apply client-side filtering by last_update_date.
+
+        This is used when updated_since or updated_in_past_hours are specified.
+        Filters properties based on when they were last updated.
+        """
+        if not homes:
+            return homes
+
+        from datetime import datetime, timedelta
+
+        # Determine date range for last_update_date filtering
+        date_range = None
+
+        if self.updated_in_past_hours:
+            cutoff_datetime = datetime.now() - timedelta(hours=self.updated_in_past_hours)
+            date_range = {'type': 'since', 'date': cutoff_datetime}
+        elif self.updated_since:
+            try:
+                since_datetime_str = self.updated_since.replace('Z', '+00:00') if self.updated_since.endswith('Z') else self.updated_since
+                since_datetime = datetime.fromisoformat(since_datetime_str).replace(tzinfo=None)
+                date_range = {'type': 'since', 'date': since_datetime}
+            except (ValueError, AttributeError):
+                return homes  # If parsing fails, return unfiltered
+
+        if not date_range:
+            return homes
+
+        filtered_homes = []
+
+        for home in homes:
+            # Extract last_update_date from the property
+            property_date = self._extract_date_from_home(home, 'last_update_date')
+
+            # Skip properties without last_update_date
+            if property_date is None:
+                continue
+
+            # Check if property date falls within the specified range
+            if self._is_datetime_in_range(property_date, date_range):
+                filtered_homes.append(home)
+
+        return filtered_homes
+
+    def _get_date_range(self):
+        """Get the date range for filtering based on instance parameters."""
+        from datetime import datetime, timedelta
+        
+        if self.last_x_days:
+            cutoff_date = datetime.now() - timedelta(days=self.last_x_days)
+            return {'type': 'since', 'date': cutoff_date}
+        elif self.date_from and self.date_to:
+            try:
+                from_date = datetime.fromisoformat(self.date_from)
+                to_date = datetime.fromisoformat(self.date_to)
+                return {'type': 'range', 'from_date': from_date, 'to_date': to_date}
+            except ValueError:
+                return None
+        return None
+    
+    def _extract_property_date_for_filtering(self, home):
+        """Extract pending_date from a property for filtering.
+        
+        Returns parsed datetime object or None.
+        """
+        date_value = self._get_pending_date(home)
+        if date_value:
+            return self._parse_date_value(date_value)
+        return None
+    
+    def _parse_date_value(self, date_value):
+        """Parse a date value (string or datetime) into a timezone-naive datetime object."""
+        from datetime import datetime
+        
+        if isinstance(date_value, datetime):
+            return date_value.replace(tzinfo=None)
+        
+        if not isinstance(date_value, str):
+            return None
+            
+        try:
+            # Handle timezone indicators
+            if date_value.endswith('Z'):
+                date_value = date_value[:-1] + '+00:00'
+            elif '.' in date_value and date_value.endswith('Z'):
+                date_value = date_value.replace('Z', '+00:00')
+            
+            # Try ISO format first
+            try:
+                parsed_date = datetime.fromisoformat(date_value)
+                return parsed_date.replace(tzinfo=None)
+            except ValueError:
+                # Try simple datetime format: '2025-08-29 00:00:00'
+                return datetime.strptime(date_value, '%Y-%m-%d %H:%M:%S')
+                
+        except (ValueError, AttributeError):
+            return None
+    
+    def _is_date_in_range(self, date_obj, date_range):
+        """Check if a datetime object falls within the specified date range."""
+        if date_range['type'] == 'since':
+            return date_obj >= date_range['date']
+        elif date_range['type'] == 'range':
+            return date_range['from_date'] <= date_obj <= date_range['to_date']
+        return False
+
+    def _apply_sort(self, homes):
+        """Apply client-side sorting to ensure results are properly ordered.
+
+        This is necessary because:
+        1. Multi-page results need to be re-sorted after concatenation
+        2. Filtering operations may disrupt the original sort order
+
+        Args:
+            homes: List of properties (either dicts or Property objects)
+
+        Returns:
+            Sorted list of properties
+        """
+        if not homes or not self.sort_by:
+            return homes
+
+        def get_sort_key(home):
+            """Extract the sort field value from a home (handles both dict and Property object)."""
+            if isinstance(home, dict):
+                value = home.get(self.sort_by)
+            else:
+                # Property object
+                value = getattr(home, self.sort_by, None)
+
+            # Handle None values - push them to the end
+            if value is None:
+                # Use a sentinel value that sorts to the end
+                return (1, 0) if self.sort_direction == "desc" else (1, float('inf'))
+
+            # For datetime fields, convert string to datetime for proper sorting
+            if self.sort_by in ['list_date', 'sold_date', 'pending_date', 'last_update_date']:
+                if isinstance(value, str):
+                    try:
+                        from datetime import datetime
+                        # Handle timezone indicators
+                        date_value = value
+                        if date_value.endswith('Z'):
+                            date_value = date_value[:-1] + '+00:00'
+                        parsed_date = datetime.fromisoformat(date_value)
+                        return (0, parsed_date)
+                    except (ValueError, AttributeError):
+                        # If parsing fails, treat as None
+                        return (1, 0) if self.sort_direction == "desc" else (1, float('inf'))
+                return (0, value)
+
+            # For numeric fields, ensure we can compare
+            return (0, value)
+
+        # Sort the homes
+        reverse = (self.sort_direction == "desc")
+        sorted_homes = sorted(homes, key=get_sort_key, reverse=reverse)
+
+        return sorted_homes
+
+    def _apply_raw_data_filters(self, homes):
+        """Apply exclude_pending and mls_only filters for raw data returns.
+
+        These filters are normally applied in process_property(), but that function
+        is bypassed when return_type="raw", so we need to apply them here instead.
+
+        Args:
+            homes: List of properties (either dicts or Property objects)
+
+        Returns:
+            Filtered list of properties
+        """
+        if not homes:
+            return homes
+
+        # Only filter raw data (dict objects)
+        # Property objects have already been filtered in process_property()
+        if homes and not isinstance(homes[0], dict):
+            return homes
+
+        filtered_homes = []
+
+        for home in homes:
+            # Apply exclude_pending filter
+            if self.exclude_pending and self.listing_type != ListingType.PENDING:
+                flags = home.get('flags', {})
+                is_pending = flags.get('is_pending', False)
+                is_contingent = flags.get('is_contingent', False)
+
+                if is_pending or is_contingent:
+                    continue  # Skip this property
+
+            # Apply mls_only filter
+            if self.mls_only:
+                source = home.get('source', {})
+                if not source or not source.get('id'):
+                    continue  # Skip this property
+
+            filtered_homes.append(home)
+
+        return filtered_homes
 
 
     @retry(

homeharvest/core/scrapers/realtor/parsers.py

@@ -250,9 +250,28 @@ def parse_description(result: dict) -> Description | None:
 def calculate_days_on_mls(result: dict) -> Optional[int]:
     """Calculate days on MLS from result data"""
     list_date_str = result.get("list_date")
-    list_date = datetime.strptime(list_date_str.split("T")[0], "%Y-%m-%d") if list_date_str else None
+    list_date = None
+    if list_date_str:
+        try:
+            # Parse full datetime, then use date() for day calculation
+            list_date_str_clean = list_date_str.replace('Z', '+00:00') if list_date_str.endswith('Z') else list_date_str
+            list_date = datetime.fromisoformat(list_date_str_clean).replace(tzinfo=None)
+        except (ValueError, AttributeError):
+            # Fallback for date-only format
+            list_date = datetime.strptime(list_date_str.split("T")[0], "%Y-%m-%d") if "T" in list_date_str else None
+
     last_sold_date_str = result.get("last_sold_date")
-    last_sold_date = datetime.strptime(last_sold_date_str, "%Y-%m-%d") if last_sold_date_str else None
+    last_sold_date = None
+    if last_sold_date_str:
+        try:
+            last_sold_date_str_clean = last_sold_date_str.replace('Z', '+00:00') if last_sold_date_str.endswith('Z') else last_sold_date_str
+            last_sold_date = datetime.fromisoformat(last_sold_date_str_clean).replace(tzinfo=None)
+        except (ValueError, AttributeError):
+            # Fallback for date-only format
+            try:
+                last_sold_date = datetime.strptime(last_sold_date_str, "%Y-%m-%d")
+            except ValueError:
+                last_sold_date = None
     today = datetime.now()
 
     if list_date:

homeharvest/core/scrapers/realtor/processors.py

@@ -121,10 +121,12 @@ def process_property(result: dict, mls_only: bool = False, extra_property_data:
         list_price=result["list_price"],
         list_price_min=result["list_price_min"],
         list_price_max=result["list_price_max"],
-        list_date=(datetime.fromisoformat(result["list_date"].split("T")[0]) if result.get("list_date") else None),
+        list_date=(datetime.fromisoformat(result["list_date"].replace('Z', '+00:00') if result["list_date"].endswith('Z') else result["list_date"]) if result.get("list_date") else None),
         prc_sqft=result.get("price_per_sqft"),
-        last_sold_date=(datetime.fromisoformat(result["last_sold_date"]) if result.get("last_sold_date") else None),
-        pending_date=(datetime.fromisoformat(result["pending_date"].split("T")[0]) if result.get("pending_date") else None),
+        last_sold_date=(datetime.fromisoformat(result["last_sold_date"].replace('Z', '+00:00') if result["last_sold_date"].endswith('Z') else result["last_sold_date"]) if result.get("last_sold_date") else None),
+        pending_date=(datetime.fromisoformat(result["pending_date"].replace('Z', '+00:00') if result["pending_date"].endswith('Z') else result["pending_date"]) if result.get("pending_date") else None),
+        last_status_change_date=(datetime.fromisoformat(result["last_status_change_date"].replace('Z', '+00:00') if result["last_status_change_date"].endswith('Z') else result["last_status_change_date"]) if result.get("last_status_change_date") else None),
+        last_update_date=(datetime.fromisoformat(result["last_update_date"].replace('Z', '+00:00') if result["last_update_date"].endswith('Z') else result["last_update_date"]) if result.get("last_update_date") else None),
         new_construction=result["flags"].get("is_new_construction") is True,
         hoa_fee=(result["hoa"]["fee"] if result.get("hoa") and isinstance(result["hoa"], dict) else None),
         latitude=(result["location"]["address"]["coordinate"].get("lat") if able_to_get_lat_long else None),
@@ -162,6 +164,25 @@ def process_property(result: dict, mls_only: bool = False, extra_property_data:
         photos=result.get("photos"),
         flags=result.get("flags"),
     )
+
+    # Enhance date precision using last_status_change_date
+    # pending_date and last_sold_date only have day-level precision
+    # last_status_change_date has hour-level precision
+    if realty_property.last_status_change_date:
+        status = realty_property.status.upper() if realty_property.status else None
+
+        # For PENDING/CONTINGENT properties, use last_status_change_date for hour-precision on pending_date
+        if status in ["PENDING", "CONTINGENT"] and realty_property.pending_date:
+            # Only replace if dates are on the same day
+            if realty_property.pending_date.date() == realty_property.last_status_change_date.date():
+                realty_property.pending_date = realty_property.last_status_change_date
+
+        # For SOLD properties, use last_status_change_date for hour-precision on last_sold_date
+        elif status == "SOLD" and realty_property.last_sold_date:
+            # Only replace if dates are on the same day
+            if realty_property.last_sold_date.date() == realty_property.last_status_change_date.date():
+                realty_property.last_sold_date = realty_property.last_status_change_date
+
     return realty_property
 
 
@@ -175,7 +196,11 @@ def process_extra_property_details(result: dict, get_key_func=None) -> dict:
         nearby_schools = result.get("nearbySchools")
         schools = nearby_schools.get("schools", []) if nearby_schools else []
         tax_history_data = result.get("taxHistory", [])
-        assessed_value = tax_history_data[0]["assessment"]["total"] if tax_history_data and tax_history_data[0].get("assessment", {}).get("total") else None
+
+        assessed_value = None
+        if tax_history_data and tax_history_data[0] and tax_history_data[0].get("assessment"):
+            assessed_value = tax_history_data[0]["assessment"].get("total")
+
         tax_history = tax_history_data
 
     if schools:

homeharvest/core/scrapers/realtor/queries.py

@@ -9,6 +9,8 @@ _SEARCH_HOMES_DATA_BASE = """{
     mls_status
     last_sold_price
     last_sold_date
+    last_status_change_date
+    last_update_date
     list_price
     list_price_max
     list_price_min
@@ -202,6 +204,11 @@ fragment HomeData on Home {
         }
     }
     taxHistory: tax_history { __typename tax year assessment { __typename building land total } }
+    property_history {
+        date
+        event_name
+        price
+    }
     monthly_fees {
         description
         display_amount

homeharvest/utils.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 import pandas as pd
+import warnings
 from datetime import datetime
 from .core.scrapers.models import Property, ListingType, Advertisers
 from .exceptions import InvalidListingType, InvalidDate
@@ -36,6 +37,8 @@ ordered_properties = [
     "sold_price",
     "last_sold_date",
     "last_sold_price",
+    "last_status_change_date",
+    "last_update_date",
     "assessed_value",
     "estimated_value",
     "tax",
@@ -119,10 +122,10 @@ def process_result(result: Property) -> pd.DataFrame:
     prop_data["nearby_schools"] = filter(None, prop_data["nearby_schools"]) if prop_data["nearby_schools"] else None
     prop_data["nearby_schools"] = ", ".join(set(prop_data["nearby_schools"])) if prop_data["nearby_schools"] else None
     
-    # Convert datetime objects to strings for CSV
-    for date_field in ["list_date", "pending_date", "last_sold_date"]:
+    # Convert datetime objects to strings for CSV (preserve full datetime including time)
+    for date_field in ["list_date", "pending_date", "last_sold_date", "last_status_change_date"]:
         if prop_data.get(date_field):
-            prop_data[date_field] = prop_data[date_field].strftime("%Y-%m-%d") if hasattr(prop_data[date_field], 'strftime') else prop_data[date_field]
+            prop_data[date_field] = prop_data[date_field].strftime("%Y-%m-%d %H:%M:%S") if hasattr(prop_data[date_field], 'strftime') else prop_data[date_field]
     
     # Convert HttpUrl objects to strings for CSV
     if prop_data.get("property_url"):
@@ -154,24 +157,45 @@ def process_result(result: Property) -> pd.DataFrame:
     return properties_df[ordered_properties]
 
 
-def validate_input(listing_type: str) -> None:
-    if listing_type.upper() not in ListingType.__members__:
-        raise InvalidListingType(f"Provided listing type, '{listing_type}', does not exist.")
+def validate_input(listing_type: str | list[str] | None) -> None:
+    if listing_type is None:
+        return  # None is valid - returns all types
+
+    if isinstance(listing_type, list):
+        for lt in listing_type:
+            if lt.upper() not in ListingType.__members__:
+                raise InvalidListingType(f"Provided listing type, '{lt}', does not exist.")
+    else:
+        if listing_type.upper() not in ListingType.__members__:
+            raise InvalidListingType(f"Provided listing type, '{listing_type}', does not exist.")
 
 
 def validate_dates(date_from: str | None, date_to: str | None) -> None:
-    if isinstance(date_from, str) != isinstance(date_to, str):
-        raise InvalidDate("Both date_from and date_to must be provided.")
+    # Allow either date_from or date_to individually, or both together
+    try:
+        # Validate and parse date_from if provided
+        date_from_obj = None
+        if date_from:
+            date_from_str = date_from.replace('Z', '+00:00') if date_from.endswith('Z') else date_from
+            date_from_obj = datetime.fromisoformat(date_from_str)
 
-    if date_from and date_to:
-        try:
-            date_from_obj = datetime.strptime(date_from, "%Y-%m-%d")
-            date_to_obj = datetime.strptime(date_to, "%Y-%m-%d")
+        # Validate and parse date_to if provided
+        date_to_obj = None
+        if date_to:
+            date_to_str = date_to.replace('Z', '+00:00') if date_to.endswith('Z') else date_to
+            date_to_obj = datetime.fromisoformat(date_to_str)
 
-            if date_to_obj < date_from_obj:
-                raise InvalidDate("date_to must be after date_from.")
-        except ValueError:
-            raise InvalidDate(f"Invalid date format or range")
+        # If both provided, ensure date_to is after date_from
+        if date_from_obj and date_to_obj and date_to_obj < date_from_obj:
+            raise InvalidDate(f"date_to ('{date_to}') must be after date_from ('{date_from}').")
+
+    except ValueError as e:
+        # Provide specific guidance on the expected format
+        raise InvalidDate(
+            f"Invalid date format. Expected ISO 8601 format. "
+            f"Examples: '2025-01-20' (date only) or '2025-01-20T14:30:00' (with time). "
+            f"Got: date_from='{date_from}', date_to='{date_to}'. Error: {e}"
+        )
 
 
 def validate_limit(limit: int) -> None:
@@ -179,3 +203,262 @@ def validate_limit(limit: int) -> None:
 
     if limit is not None and (limit < 1 or limit > 10000):
         raise ValueError("Property limit must be between 1 and 10,000.")
+
+
+def validate_offset(offset: int, limit: int = 10000) -> None:
+    """Validate offset parameter for pagination.
+
+    Args:
+        offset: Starting position for results pagination
+        limit: Maximum number of results to fetch
+
+    Raises:
+        ValueError: If offset is invalid or if offset + limit exceeds API limit
+    """
+    if offset is not None and offset < 0:
+        raise ValueError("Offset must be non-negative (>= 0).")
+
+    # Check if offset + limit exceeds API's hard limit of 10,000
+    if offset is not None and limit is not None and (offset + limit) > 10000:
+        raise ValueError(
+            f"offset ({offset}) + limit ({limit}) = {offset + limit} exceeds API maximum of 10,000. "
+            f"The API cannot return results beyond position 10,000. "
+            f"To fetch more results, narrow your search."
+        )
+
+    # Warn if offset is not a multiple of 200 (API page size)
+    if offset is not None and offset > 0 and offset % 200 != 0:
+        warnings.warn(
+            f"Offset should be a multiple of 200 (page size) for optimal performance. "
+            f"Using offset {offset} may result in less efficient pagination.",
+            UserWarning
+        )
+
+
+def validate_datetime(datetime_value) -> None:
+    """Validate datetime value (accepts datetime objects or ISO 8601 strings)."""
+    if datetime_value is None:
+        return
+
+    # Already a datetime object - valid
+    from datetime import datetime as dt, date
+    if isinstance(datetime_value, (dt, date)):
+        return
+
+    # Must be a string - validate ISO 8601 format
+    if not isinstance(datetime_value, str):
+        raise InvalidDate(
+            f"Invalid datetime value. Expected datetime object, date object, or ISO 8601 string. "
+            f"Got: {type(datetime_value).__name__}"
+        )
+
+    try:
+        # Try parsing as ISO 8601 datetime
+        datetime.fromisoformat(datetime_value.replace('Z', '+00:00'))
+    except (ValueError, AttributeError):
+        raise InvalidDate(
+            f"Invalid datetime format: '{datetime_value}'. "
+            f"Expected ISO 8601 format (e.g., '2025-01-20T14:30:00' or '2025-01-20')."
+        )
+
+
+def validate_last_update_filters(updated_since: str | None, updated_in_past_hours: int | None) -> None:
+    """Validate last_update_date filtering parameters."""
+    if updated_since and updated_in_past_hours:
+        raise ValueError(
+            "Cannot use both 'updated_since' and 'updated_in_past_hours' parameters together. "
+            "Please use only one method to filter by last_update_date."
+        )
+
+    # Validate updated_since format if provided
+    if updated_since:
+        validate_datetime(updated_since)
+
+    # Validate updated_in_past_hours range if provided
+    if updated_in_past_hours is not None:
+        if updated_in_past_hours < 1:
+            raise ValueError(
+                f"updated_in_past_hours must be at least 1. Got: {updated_in_past_hours}"
+            )
+
+
+def validate_filters(
+    beds_min: int | None = None,
+    beds_max: int | None = None,
+    baths_min: float | None = None,
+    baths_max: float | None = None,
+    sqft_min: int | None = None,
+    sqft_max: int | None = None,
+    price_min: int | None = None,
+    price_max: int | None = None,
+    lot_sqft_min: int | None = None,
+    lot_sqft_max: int | None = None,
+    year_built_min: int | None = None,
+    year_built_max: int | None = None,
+) -> None:
+    """Validate that min values are less than max values for range filters."""
+    ranges = [
+        ("beds", beds_min, beds_max),
+        ("baths", baths_min, baths_max),
+        ("sqft", sqft_min, sqft_max),
+        ("price", price_min, price_max),
+        ("lot_sqft", lot_sqft_min, lot_sqft_max),
+        ("year_built", year_built_min, year_built_max),
+    ]
+
+    for name, min_val, max_val in ranges:
+        if min_val is not None and max_val is not None and min_val > max_val:
+            raise ValueError(f"{name}_min ({min_val}) cannot be greater than {name}_max ({max_val}).")
+
+
+def validate_sort(sort_by: str | None, sort_direction: str | None = "desc") -> None:
+    """Validate sort parameters."""
+    valid_sort_fields = ["list_date", "sold_date", "list_price", "sqft", "beds", "baths", "last_update_date"]
+    valid_directions = ["asc", "desc"]
+
+    if sort_by and sort_by not in valid_sort_fields:
+        raise ValueError(
+            f"Invalid sort_by value: '{sort_by}'. "
+            f"Valid options: {', '.join(valid_sort_fields)}"
+        )
+
+    if sort_direction and sort_direction not in valid_directions:
+        raise ValueError(
+            f"Invalid sort_direction value: '{sort_direction}'. "
+            f"Valid options: {', '.join(valid_directions)}"
+        )
+
+
+def convert_to_datetime_string(value) -> str | None:
+    """
+    Convert datetime object or string to ISO 8601 string format.
+
+    Accepts:
+    - datetime.datetime objects
+    - datetime.date objects
+    - ISO 8601 strings (returned as-is)
+    - None (returns None)
+
+    Returns ISO 8601 formatted string or None.
+    """
+    if value is None:
+        return None
+
+    # Already a string - return as-is
+    if isinstance(value, str):
+        return value
+
+    # datetime.datetime object
+    from datetime import datetime, date
+    if isinstance(value, datetime):
+        return value.isoformat()
+
+    # datetime.date object (convert to datetime at midnight)
+    if isinstance(value, date):
+        return datetime.combine(value, datetime.min.time()).isoformat()
+
+    raise ValueError(
+        f"Invalid datetime value. Expected datetime object, date object, or ISO 8601 string. "
+        f"Got: {type(value).__name__}"
+    )
+
+
+def extract_timedelta_hours(value) -> int | None:
+    """
+    Extract hours from int or timedelta object.
+
+    Accepts:
+    - int (returned as-is)
+    - timedelta objects (converted to total hours)
+    - None (returns None)
+
+    Returns integer hours or None.
+    """
+    if value is None:
+        return None
+
+    # Already an int - return as-is
+    if isinstance(value, int):
+        return value
+
+    # timedelta object - convert to hours
+    from datetime import timedelta
+    if isinstance(value, timedelta):
+        return int(value.total_seconds() / 3600)
+
+    raise ValueError(
+        f"Invalid past_hours value. Expected int or timedelta object. "
+        f"Got: {type(value).__name__}"
+    )
+
+
+def extract_timedelta_days(value) -> int | None:
+    """
+    Extract days from int or timedelta object.
+
+    Accepts:
+    - int (returned as-is)
+    - timedelta objects (converted to total days)
+    - None (returns None)
+
+    Returns integer days or None.
+    """
+    if value is None:
+        return None
+
+    # Already an int - return as-is
+    if isinstance(value, int):
+        return value
+
+    # timedelta object - convert to days
+    from datetime import timedelta
+    if isinstance(value, timedelta):
+        return int(value.total_seconds() / 86400)  # 86400 seconds in a day
+
+    raise ValueError(
+        f"Invalid past_days value. Expected int or timedelta object. "
+        f"Got: {type(value).__name__}"
+    )
+
+
+def detect_precision_and_convert(value):
+    """
+    Detect if input has time precision and convert to ISO string.
+
+    Accepts:
+    - datetime.datetime objects → (ISO string, "hour")
+    - datetime.date objects → (ISO string at midnight, "day")
+    - ISO 8601 datetime strings with time → (string as-is, "hour")
+    - Date-only strings "YYYY-MM-DD" → (string as-is, "day")
+    - None → (None, None)
+
+    Returns:
+        tuple: (iso_string, precision) where precision is "day" or "hour"
+    """
+    if value is None:
+        return (None, None)
+
+    from datetime import datetime as dt, date
+
+    # datetime.datetime object - has time precision
+    if isinstance(value, dt):
+        return (value.isoformat(), "hour")
+
+    # datetime.date object - day precision only
+    if isinstance(value, date):
+        # Convert to datetime at midnight
+        return (dt.combine(value, dt.min.time()).isoformat(), "day")
+
+    # String - detect if it has time component
+    if isinstance(value, str):
+        # ISO 8601 datetime with time component (has 'T' and time)
+        if 'T' in value:
+            return (value, "hour")
+        # Date-only string
+        else:
+            return (value, "day")
+
+    raise ValueError(
+        f"Invalid date value. Expected datetime object, date object, or ISO 8601 string. "
+        f"Got: {type(value).__name__}"
+    )

poetry.lock

@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 2.1.3 and should not be changed by hand.
+# This file is automatically @generated by Poetry 2.2.1 and should not be changed by hand.
 
 [[package]]
 name = "annotated-types"
@@ -943,5 +943,5 @@ test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess
 
 [metadata]
 lock-version = "2.1"
-python-versions = ">=3.9,<3.13"
-content-hash = "17de7786a5e0bc51f4f42b6703dc41564050f8696a1b5d2e315ceffe6e192309"
+python-versions = ">=3.9"
+content-hash = "c60c33aa5f054998b90bd1941c825c9ca1867a53e64c07e188b91da49c7741a4"

pyproject.toml

@@ -1,16 +1,13 @@
 [tool.poetry]
 name = "homeharvest"
-version = "0.5.1"
+version = "0.8.0"
 description = "Real estate scraping library"
 authors = ["Zachary Hampton <zachary@bunsly.com>", "Cullen Watson <cullen@bunsly.com>"]
-homepage = "https://github.com/Bunsly/HomeHarvest"
+homepage = "https://github.com/ZacharyHampton/HomeHarvest"
 readme = "README.md"
 
-[tool.poetry.scripts]
-homeharvest = "homeharvest.cli:main"
-
 [tool.poetry.dependencies]
-python = ">=3.9,<3.13"
+python = ">=3.9"
 requests = "^2.32.4"
 pandas = "^2.3.1"
 pydantic = "^2.11.7"