### API Reference Introduction and FAQ

Source: https://docs.realie.ai/api-reference/property-data-schema

Links to introductory guides and frequently asked questions for the Realie Property Data API, covering getting started, pricing, and response codes.

```APIDOC
API Reference Introduction: /api-reference/introduction
API FAQ: /api-reference/faq
API Pricing Tiers: /api-reference/pricing
Response Codes: /api-reference/response-codes
Property Data Schema: /api-reference/property-data-schema
Property Feature Field Key: /api-reference/feature-key
```

--------------------------------

### Example Response for Premium Comparables Search

Source: https://docs.realie.ai/api-reference/premium/premium-comparables-search

Example JSON response structure for a successful premium comparables search query.

```json
{
  "comparables": [
    {}
  ],
  "metadata": {
    "count": 123,
    "searchParams": {}
  }
}
```

--------------------------------

### Example Request for Premium Comparables Search

Source: https://docs.realie.ai/api-reference/premium/premium-comparables-search

Example cURL command to perform a premium comparables search using the Realie Property Data API.

```curl
curl --request GET \
  --url https://app.realie.ai/api/public/premium/comparables/ \
  --header 'Authorization: <api-key>'
```

--------------------------------

### Location Search cURL Example

Source: https://docs.realie.ai/api-reference/property/location-search

Example of how to make a GET request to the Location Search API endpoint using cURL, including authorization.

```curl
curl --request GET \
  --url https://app.realie.ai/api/public/property/location/ \
  --header 'Authorization: <api-key>'
```

--------------------------------

### Premium Comparables Search API Endpoint

Source: https://docs.realie.ai/api-reference/property/owner-search

This section details the GET request for premium comparables searches. It includes the endpoint URL, required headers, query parameters, and example response payloads.

```APIDOC
GET /public/premium/premium-comparables-search/

Description:
  Performs a premium comparables search for properties.

Authorization:
  Authorization: string (header, required) - Provide your API key directly in the header.

Query Parameters:
  address: string (required) - The street address of the property.
  city: string (required) - The city where the property is located.
  state: string (required) - The state (e.g. CA) where the property is located.
  zipCode: string (optional) - The zip code of the property.
  limit: integer (optional, default:10) - Maximum number of results to return. Defaults to 10, maximum is 100. Required range: 1 <= x <= 100.
  offset: integer (optional, default:0) - Number of records to skip. Defaults to 0. Required range: x >= 0.

Responses:
  200 OK: Properties found successfully. Response body is of type object.
  400 Bad Request: Invalid input parameters.
  401 Unauthorized: Authentication failed.
  403 Forbidden: Insufficient permissions.
  404 Not Found: Resource not found.
  500 Internal Server Error: Server error.

Related Endpoints:
  - [Premium Owner Search](/api-reference/premium/premium-owner-search)
  - [Owner Search](/api-reference/property/owner-search)
```

--------------------------------

### Pagination Example (Python)

Source: https://docs.realie.ai/code-references

This Python script demonstrates how to paginate through property search results for Monterey County using limit and offset parameters. It iteratively fetches batches of results from the API until no more data is returned, printing each batch.

```Python
import requests

# Set the request headers with your API Key
headers = {"Authorization": "<YOUR_API_KEY>"}

# Define the API endpoint URL
url = "https://app.realie.ai/api/public/property/search/"

# Parameters for pagination
params = {
    "county": "Monterey",
    "limit": 100,  # Number of results per page
    "offset": 0   # Starting point for results
}

all_results = []

while True:
    # Make the API request
    response = requests.get(url, headers=headers, params=params)

    # Check if the request was successful
    if response.status_code == 200:
        data = response.json()
        results = data.get("results", [])

        if not results:
            # No more results, break the loop
            break

        # Process the current batch of results
        print(f"Received {len(results)} results (Offset: {params['offset']})")
        all_results.extend(results)

        # Prepare for the next page
        params["offset"] += params["limit"]
    else:
        # Handle API errors
        print(f"Error fetching data: {response.status_code} - {response.text}")
        break

# Print a summary or process all_results
print(f"\nTotal properties fetched: {len(all_results)}")

# Example: Print the first 5 property IDs
# for i, prop in enumerate(all_results[:5]):
#     print(f"  {i+1}. ID: {prop.get('id')}")

```

--------------------------------

### Address Lookup cURL Example

Source: https://docs.realie.ai/api-reference/property/address-lookup

Example of how to call the Address Lookup API endpoint using cURL, including the necessary authorization header.

```curl
curl --request GET \
  --url https://app.realie.ai/api/public/property/address/ \
  --header 'Authorization: <api-key>'
```

--------------------------------

### Location Search Response Example

Source: https://docs.realie.ai/api-reference/property/location-search

Example JSON response structure for a successful Location Search API request.

```json
{
  "properties": [
    {}
  ],
  "metadata": {
    "limit": 123,
    "offset": 123,
    "count": 123,
    "searchCenter": {
      "longitude": 123,
      "latitude": 123
    },
    "radiusMiles": 123
  }
}
```

--------------------------------

### Property Search API Endpoint

Source: https://docs.realie.ai/api-reference/property/owner-search

This section details the GET request for searching properties by address. It includes the endpoint URL, required headers, query parameters, and example response payloads.

```APIDOC
GET /public/property/address-lookup/

Description:
  Performs a property search by address.

Authorization:
  Authorization: string (header, required) - Provide your API key directly in the header.

Query Parameters:
  address: string (required) - The street address of the property.
  city: string (required) - The city where the property is located.
  state: string (required) - The state (e.g. CA) where the property is located.
  zipCode: string (optional) - The zip code of the property.
  limit: integer (optional, default:10) - Maximum number of results to return. Defaults to 10, maximum is 100. Required range: 1 <= x <= 100.
  offset: integer (optional, default:0) - Number of records to skip. Defaults to 0. Required range: x >= 0.

Responses:
  200 OK: Properties found successfully. Response body is of type object.
  400 Bad Request: Invalid input parameters.
  401 Unauthorized: Authentication failed.
  403 Forbidden: Insufficient permissions.
  404 Not Found: Resource not found.
  500 Internal Server Error: Server error.

Related Endpoints:
  - [Owner Search](/api-reference/property/owner-search)
  - [Parcel ID Lookup](/api-reference/property/parcel-id-lookup)
```

--------------------------------

### Property Search Response Example

Source: https://docs.realie.ai/api-reference/property/property-search

Example JSON response structure for a successful property search query from the Realie Property Data API. It includes an array of property objects and metadata about the pagination.

```json
{
  "properties": [
    {}
  ],
  "metadata": {
    "limit": 123,
    "offset": 123,
    "count": 123
  }
}
```

--------------------------------

### Premium Owner Search API Endpoint

Source: https://docs.realie.ai/api-reference/property/owner-search

This section details the GET request for premium owner searches. It includes the endpoint URL, required headers, query parameters, and example response payloads.

```APIDOC
GET /public/premium/premium-owner-search/

Description:
  Performs a premium owner search for properties.

Authorization:
  Authorization: string (header, required) - Provide your API key directly in the header.

Query Parameters:
  state: string (required) - The state (e.g. CA) where the property is located.
  lastName: string (required) - The last name of the property owner or company name.
  firstName: string (optional) - The first name of the property owner.
  limit: integer (optional, default:10) - Maximum number of results to return. Defaults to 10, maximum is 100. Required range: 1 <= x <= 100.
  offset: integer (optional, default:0) - Number of records to skip. Defaults to 0. Required range: x >= 0.

Responses:
  200 OK: Properties found successfully. Response body is of type object.
  400 Bad Request: Invalid input parameters.
  401 Unauthorized: Authentication failed.
  403 Forbidden: Insufficient permissions.
  404 Not Found: Resource not found.
  500 Internal Server Error: Server error.

Related Endpoints:
  - [Owner Search](/api-reference/property/owner-search)
  - [Premium Comparables Search](/api-reference/premium/premium-comparables-search)
```

--------------------------------

### Property Transfers JSON Example

Source: https://docs.realie.ai/api-reference/property-data-schema

An example JSON array detailing past property transfer information, including dates, prices, parties involved, and recording details.

```JSON
"transfers": [
{
          "transferDate": "20160427",
          "transferDateObject": "2016-04-27T00:00:00.000Z",
          "transferPrice": 2700000,
          "grantee": "SMITH, JOHN",
          "grantor": "JEAN, BILL",
          "recordingDate": "20160505"
}
]
```

--------------------------------

### Owner Search API Endpoint

Source: https://docs.realie.ai/api-reference/property/owner-search

This section details the GET request for searching property owners. It includes the endpoint URL, required headers, query parameters, and example request/response payloads.

```APIDOC
GET /public/property/owner/

Description:
  Performs an owner search for properties.

Authorization:
  Authorization: string (header, required) - Provide your API key directly in the header.

Query Parameters:
  state: string (required) - The state (e.g. CA) where the property is located.
  lastName: string (required) - The last name of the property owner or company name.
  firstName: string (optional) - The first name of the property owner.
  limit: integer (optional, default:10) - Maximum number of results to return. Defaults to 10, maximum is 100. Required range: 1 <= x <= 100.
  offset: integer (optional, default:0) - Number of records to skip. Defaults to 0. Required range: x >= 0.

Responses:
  200 OK: Properties found successfully. Response body is of type object.
    Example:
    {
      "properties": [
        {}
      ],
      "metadata": {
        "limit": 123,
        "count": 123
      }
    }
  400 Bad Request: Invalid input parameters.
  401 Unauthorized: Authentication failed.
  403 Forbidden: Insufficient permissions.
  404 Not Found: Resource not found.
  500 Internal Server Error: Server error.

Related Endpoints:
  - [Parcel ID Lookup](/api-reference/property/parcel-id-lookup)
  - [Location Search](/api-reference/property/location-search)
```

```curl
curl --request GET \
  --url https://app.realie.ai/api/public/property/owner/ \
  --header 'Authorization: <api-key>'
```

--------------------------------

### API Parameters and Data Fields

Source: https://docs.realie.ai/api-reference/property-data-schema

Defines the parameters and data fields used within the Realie AI system, covering foreclosure information, location details, and property geometry. Includes descriptions, types, and examples for key fields.

```APIDOC
forecloseFileDate
  Type: string
  Description: Foreclosure File Date (YYYYMMDD Format). Example: "2024-01-10"

forecloseCaseNum
  Type: string
  Description: Foreclosure Case Number. Example: "722324"

auctionDate
  Type: string
  Description: Auction Date (YYYYMMDD Format). Example: "2024-01-10"

Location Data:

fipsState
  Type: string
  Description: FIPS State Code. Example: "48"

fipsCounty
  Type: string
  Description: FIPS County Code. Example: "085"

siteCensusTract
  Type: string
  Description: Site Census Tract. Example: "480850316.682028"

neighborhood
  Type: string
  Description: Neighborhood. Example: "CENTRAL PLANO"

longitude
  Type: float
  Description: Longitude. Example: -96.8229693260567

latitude
  Type: float
  Description: Latitude. Example: 33.03128999789361

siteId
  Type: string
  Description: Site ID. Example: "708040968"

location
  Type: geojson
  Description: Geojson point object.
  Example:
    {
      "type": "Point",
      "coordinates": [
          -121.88081453613906,
          36.52594926758319
      ]
    }

geometry
  Type: geojson
  Description: Geojson MultiPolygon showing a property’s parcel polygon
  Example:
    {
      "type": "MultiPolygon",
      "coordinates": [
        [
          [
            [-88.0153597, 42.0000236],
            [-88.0153815, 42.0003284],
            [-88.0156542, 42.0003187],
            [-88.0156365, 42.0000141],
            [-88.0155919, 42.0000157],
            [-88.015467, 42.0000199],
            [-88.0153597, 42.0000236]
          ]
        ]
      ]
    }
```

--------------------------------

### Example cURL Request for Parcel ID Lookup

Source: https://docs.realie.ai/api-reference/property/parcel-id-lookup

Demonstrates how to make a GET request to the Parcel ID Lookup API endpoint using cURL, including the necessary authorization header.

```curl
curl --request GET \
  --url https://app.realie.ai/api/public/property/parcelId/ \
  --header 'Authorization: <api-key>'
```

--------------------------------

### Property Search cURL Example

Source: https://docs.realie.ai/api-reference/property/property-search

Example cURL command to perform a property search using the Realie Property Data API. It demonstrates how to include the authorization header and the base URL for the search endpoint.

```curl
curl --request GET \
  --url https://app.realie.ai/api/public/property/search/ \
  --header 'Authorization: <api-key>'
```

--------------------------------

### Property Valuation and Tax Data Fields

Source: https://docs.realie.ai/api-reference/property-data-schema

Defines the data fields related to property valuation, assessed values, and tax information. Includes parameter names, types, descriptions, and example values.

```APIDOC
tractNumber: string
  Description: Tract Number. Example: "1003"

acres: float
  Description: Acres. Example: 0.32

depthSize: float
  Description: Depth Size. Example: 150

frontage: float
  Description: Frontage. Example: 100

landArea: float
  Description: Land Area. Example: 14096

totalAssessedValue: float
  Description: Most recent total assessed value. Example: 1669610

assessedYear: integer
  Description: Most recent assessed year. Example: 2024

taxValue: float
  Description: Most recent property tax amount. Example: 17642.22

taxYear: integer
  Description: Most recent property tax year. Example: 2024

totalBuildingValue: float
  Description: Most recent assessed total building value. Example: 400110

totalLandValue: float
  Description: Most recent assessed land vaulue. Example: 269500

totalMarketValue: float
  Description: Most recent assessed market value. Example: 1669610

marketValueYear: integer
  Description: Most recent assessed market value year. Example: 2024

taxRateCodeArea: string
  Description: Tax Rate Code Area. Example: "GCN"

useCode: string
  Description: Parcel’s Use Code. Example: "1001"

modelValue: float
  Description: Model Value. Example: 1739895

modelValueMin: float
  Description: Model Value Minimum. Example: 1496309

modelValueMax: float
  Description: Model Value Maximum. Example: 1983480

modelValueStdDev: float
  Description: Model Value Standard Deviation. Example: 14

modelConfidence: float
  Description: Model Confidence. Example: 86

modelDate: string
  Description: Model Date (YYYYMMDD Format). Example: "2024-01-10"
```

--------------------------------

### Property Assessments JSON Example

Source: https://docs.realie.ai/api-reference/property-data-schema

An example JSON array representing historical assessment information for a property, including assessed year, values, and tax data.

```JSON
"assessments": [
       {
           "assessedYear": 2023,
           "totalAssessedValue": 3072135,
           "totalBuildingValue": 2572135,
           "totalLandValue": 500000,
           "totalMarketValue": 4072135,
           "marketValueYear": 2023,
           "taxValue": 34435.7,
           "taxYear": 2023
       }
]
```

--------------------------------

### Location Search API Endpoint

Source: https://docs.realie.ai/api-reference/property/owner-search

This section details the GET request for searching properties by geographic location. It includes the endpoint URL, required headers, query parameters, and example response payloads.

```APIDOC
GET /public/property/location-search/

Description:
  Performs a property search by geographic location (e.g., latitude and longitude).

Authorization:
  Authorization: string (header, required) - Provide your API key directly in the header.

Query Parameters:
  latitude: float (required) - The latitude of the location.
  longitude: float (required) - The longitude of the location.
  radius: integer (optional, default:1000) - The radius in meters to search within.
  limit: integer (optional, default:10) - Maximum number of results to return. Defaults to 10, maximum is 100. Required range: 1 <= x <= 100.
  offset: integer (optional, default:0) - Number of records to skip. Defaults to 0. Required range: x >= 0.

Responses:
  200 OK: Properties found successfully. Response body is of type object.
  400 Bad Request: Invalid input parameters.
  401 Unauthorized: Authentication failed.
  403 Forbidden: Insufficient permissions.
  404 Not Found: Resource not found.
  500 Internal Server Error: Server error.

Related Endpoints:
  - [Owner Search](/api-reference/property/owner-search)
  - [Address Lookup](/api-reference/property/address-lookup)
```

--------------------------------

### Parcel ID Lookup API Endpoint

Source: https://docs.realie.ai/api-reference/property/owner-search

This section details the GET request for searching properties by Parcel ID. It includes the endpoint URL, required headers, query parameters, and example response payloads.

```APIDOC
GET /public/property/parcel-id-lookup/

Description:
  Performs a property search by Parcel ID.

Authorization:
  Authorization: string (header, required) - Provide your API key directly in the header.

Query Parameters:
  parcelId: string (required) - The Parcel ID of the property.
  state: string (required) - The state (e.g. CA) where the property is located.
  limit: integer (optional, default:10) - Maximum number of results to return. Defaults to 10, maximum is 100. Required range: 1 <= x <= 100.
  offset: integer (optional, default:0) - Number of records to skip. Defaults to 0. Required range: x >= 0.

Responses:
  200 OK: Properties found successfully. Response body is of type object.
  400 Bad Request: Invalid input parameters.
  401 Unauthorized: Authentication failed.
  403 Forbidden: Insufficient permissions.
  404 Not Found: Resource not found.
  500 Internal Server Error: Server error.

Related Endpoints:
  - [Owner Search](/api-reference/property/owner-search)
  - [Address Lookup](/api-reference/property/address-lookup)
```

--------------------------------

### Property Search API Endpoint

Source: https://docs.realie.ai/api-reference/property/property-search

This section details the GET /api/public/property/search/ endpoint for retrieving property data. It includes query parameters for filtering properties by location, transfer date, use code, and more, along with authorization requirements and response structure.

```APIDOC
GET /api/public/property/search/

Description:
  Retrieves property data based on specified search criteria.

Tip:
  For best performance and lowest latency, supply the state (two letter abbreviation), county, and address fields. ZIP codes and city names often vary between data sources and may impact lookup accuracy.

Query Parameters:
  state (string, required when using county, city, or zipCode): The state (e.g. “CA”) where the property is located.
  zipCode (string, required when using state): The ZIP code of the property.
  county (string, required when using state): The county where the property is located.
  city (string, required when using state): The city where the property is located.
  transferedSince (string): Number of days to look back for property transfers. Returns properties that were transferred within the specified number of days.
  useCode (integer, required when using state): The numerical code that identifies the use of a property (e.g., residential, commercial, etc.).
  address (string): The street address only (e.g. “123 Main Street”). Do not include city, state, or ZIP.
  unitNumberStripped (string): The unit number of the property (optional). Do not include the type of unit. (e.g. “APT 2B” would just be “2B”)
  limit (integer, default:10): Maximum number of results to return. Defaults to 10, maximum is 100. Required range: 1 <= x <= 100.
  offset (integer, default:0): Number of records to skip. Defaults to 0. Required range: x >= 0.
  residential (boolean): Filter for residential properties only. If true, returns only residential properties. If false, returns only non-residential properties.

Authorizations:
  Authorization (string, header, required): Provide your API key directly in the header.

Responses:
  200 (application/json): Properties found successfully.
    Properties found successfully
    The response is of type object.
    {
      "properties": [
        {}
      ],
      "metadata": {
        "limit": 123,
        "offset": 123,
        "count": 123
      }
    }
  400 (application/json): Bad Request
  401 (application/json): Unauthorized
  403 (application/json): Forbidden
  404 (application/json): Not Found
  500 (application/json): Internal Server Error

Related Endpoints:
  Address Lookup: /api/public/property/address-lookup
  Parcel ID Lookup: /api/public/property/parcel-id-lookup
  Owner Search: /api/public/property/owner-search
  Location Search: /api/public/property/location-search
```

--------------------------------

### API Authentication and Usage

Source: https://docs.realie.ai/api-reference/introduction

Instructions on how to obtain and use your API key for authentication. The API key must be included in the headers of all API requests.

```APIDOC
Authentication:
  Include your API key in the request headers.
  Example Header:
  Authorization: Bearer YOUR_API_KEY
```

--------------------------------

### API Key Generation and Usage

Source: https://docs.realie.ai/api-reference/faq

Information on how to generate and manage API keys for accessing the Realie Property Data API. It includes details on activation requirements and usage limits.

```APIDOC
API Key Generation:
  - Location: Access via the 'developer tab' on the Realie platform after signing in.
  - Activation: Requires providing a valid payment method for free tier subscription activation.
  - Purpose of Payment Method: Ensures seamless coverage for API usage exceeding the monthly allotment.

API Request Limits:
  - Standard Limit: 1,200 requests per minute.
  - Enterprise Customers: Limits can be raised by contacting support@realie.ai.

Account Management:
  - Downgrade: Option to downgrade to the Free Tier, with the current paid tier remaining active until the end of the billing cycle.
  - Delete Account: Accessible via profile icon -> 'Manage Account' -> 'Security Settings'.
  - Overage Charges: API overage requests incurred before account deletion will be charged.
```

--------------------------------

### Property Data Normalization and Verification

Source: https://docs.realie.ai/api-reference/faq

Guidance on normalizing unit numbers and verifying address data against external sources to ensure accurate property lookups.

```APIDOC
Unit Number Normalization:
  - Rule: Remove leading identifiers (e.g., 'APT 103B' should become '103B').
  - Tool: A script is available on the Code Reference Library Page to assist with normalization.

Address Verification:
  - Method: Use the Platform’s Property Lookup Feature (which uses Google Maps latitude and longitude data).
  - Purpose: To verify if an address is correct and if corresponding parcel information exists in the Realie database.
  - Address Formatting: Adheres to USPS standards, accounting for abbreviations and directional indicators.
```

--------------------------------

### Premium Property Data Endpoints

Source: https://docs.realie.ai/api-reference/faq

Offers access to enhanced property data, including premium owner searches and comparable sales data. These endpoints are designed for users requiring more in-depth market analysis and owner information.

```APIDOC
GET /api-reference/premium/premium-owner-search
  Description: Performs an advanced search for property owners.
  Parameters: (Details not provided in source text)
  Returns: (Details not provided in source text)

GET /api-reference/premium/premium-comparables-search
  Description: Retrieves comparable sales data for properties.
  Parameters: (Details not provided in source text)
  Returns: (Details not provided in source text)
```

--------------------------------

### Premium API Endpoints

Source: https://docs.realie.ai/api-reference/property/property-search

Details the available endpoints for accessing premium property data, specifically for owner searches and comparable property searches.

```APIDOC
GET /api/public/premium/premium-owner-search
GET /api/public/premium/premium-comparables-search
```

--------------------------------

### Realie Premium API Endpoints

Source: https://docs.realie.ai/api-reference/pricing

Offers access to advanced premium features for property data analysis. This includes specialized owner searches and comparative market analysis (comparables search), designed for users needing deeper insights or specific market data.

```APIDOC
GET /api-reference/premium/premium-owner-search
  Description: Conducts an advanced search for property owners, potentially with more detailed criteria than the standard owner search.
  Parameters: (Details not provided in source text)
  Returns: (Details not provided in source text)

GET /api-reference/premium/premium-comparables-search
  Description: Provides data for comparable properties, useful for market analysis and valuation.
  Parameters: (Details not provided in source text)
  Returns: (Details not provided in source text)
```

--------------------------------

### Premium Property Search Endpoints

Source: https://docs.realie.ai/api-reference/feature-key

Provides access to premium features for enhanced property data searches, including advanced owner searches and comparable property analysis.

```APIDOC
GET /api-reference/premium/premium-owner-search
  Description: Performs an advanced search for property owners, potentially including more data points or broader matching.
  Parameters:
    - owner_name: (string, required) The name of the property owner.
    - city: (string, optional) Filter by city.
    - state: (string, optional) Filter by state.
    - advanced_filters: (object, optional) Additional criteria for advanced owner search.
  Returns:
    - Array of premium property owner data.

GET /api-reference/premium/premium-comparables-search
  Description: Finds comparable properties based on specific criteria for valuation or market analysis.
  Parameters:
    - property_id: (string, required) The ID of the subject property.
    - comparable_criteria: (object, required) Criteria for finding comparables (e.g., square footage range, year built, location proximity).
    - limit: (integer, optional) Maximum number of comparables to return.
  Returns:
    - Array of comparable property data.
```

--------------------------------

### foundationType Key Mappings (APIDOC)

Source: https://docs.realie.ai/api-reference/feature-key

Defines the mapping between single-letter codes and descriptions for different foundation types. This is used to categorize the structural base of a building.

```APIDOC
foundationType Key:
  Maps foundation type codes to their descriptions.
  Parameters:
    Code: The single-letter identifier for the foundation type.
    Description: A textual description of the foundation type.
  Example Mappings:
    A: Aggregate Pier
    B: Basement Foundation
    C: Crawl Space
    Z: Zoned Engineered Foundation
```

--------------------------------

### wallType Key Mappings (APIDOC)

Source: https://docs.realie.ai/api-reference/feature-key

Defines the mapping between single-letter codes and descriptions for different wall types. This is used to categorize the exterior material of a building.

```APIDOC
wallType Key:
  Maps building material codes to their descriptions.
  Parameters:
    Code: The single-letter identifier for the wall type.
    Description: A textual description of the wall material.
  Example Mappings:
    A: Aluminum Siding
    B: Brick Veneer
    C: Concrete Block
    Z: Zinc Cladding
```

--------------------------------

### Fetch API Data with Pagination in Python

Source: https://docs.realie.ai/code-references

This Python script fetches data from a specified URL in batches using the 'requests' library. It implements a pagination strategy by incrementing an 'offset' based on a 'limit' to retrieve all records. The code includes error handling for API responses and breaks the loop when no more data is returned.

```Python
# Set the number of records to fetch per request (limit) and initialize the offset
limit = 10
offset = 0

while True:
    # Define query parameters including limit, offset, county, and state
    params = {"limit": limit, "offset": offset, "county": "MONTEREY", "state": "CA"}

    # Send a GET request to the API with the headers and parameters
    # Assuming 'url' and 'headers' are defined elsewhere
    # response = requests.get(url, headers=headers, params=params)
    
    # Placeholder for actual request for demonstration
    print(f"Simulating GET request with params: {params}")
    # In a real scenario, you would uncomment the line above and remove this placeholder
    # For this example, we'll simulate a successful response structure
    class MockResponse:
        def __init__(self, status_code, json_data):
            self.status_code = status_code
            self._json_data = json_data
        def json(self):
            return self._json_data
        @property
        def text(self):
            return "Mock Error Text"

    # Simulate a response with data for the first few calls, then empty
    if offset < 30:
        mock_properties = [{"id": i, "name": f"Property {i}"} for i in range(offset, offset + limit)]
        response = MockResponse(200, {"properties": mock_properties})
    else:
        response = MockResponse(200, {"properties": []})

    # Check if the response returned a non-200 status code
    if response.status_code != 200:
        print("Error:", response.status_code, response.text)
        break

    # Parse the JSON response and extract the list of properties
    properties = response.json().get("properties", [])

    # Print the current offset and how many properties were fetched
    print(f"Offset: {offset} | Fetched {len(properties)} properties")

    # If no properties are returned, exit the loop
    if not properties:
        break

    # Loop through each property and print its details
    for prop in properties:
        print(prop)

    # Increase the offset by the limit to fetch the next batch
    offset += limit

# Print a final message after finishing the loop
print("Finished looping through parcels.")
```

--------------------------------

### Premium Property Data API Endpoints

Source: https://docs.realie.ai/api-reference/property-data-schema

Endpoints for accessing premium property data, including advanced owner searches and comparable property analysis.

```APIDOC
GET /api-reference/premium/premium-owner-search
  Description: Performs an advanced search for properties based on premium owner data.
  Parameters: (Details not provided in source text)
  Returns: (Details not provided in source text)

GET /api-reference/premium/premium-comparables-search
  Description: Retrieves comparable property data for analysis.
  Parameters: (Details not provided in source text)
  Returns: (Details not provided in source text)
```

--------------------------------

### basementType Key Mappings (APIDOC)

Source: https://docs.realie.ai/api-reference/feature-key

Defines the mapping between single-letter codes and descriptions for various basement types. This is used to categorize the configuration and finish of a building's basement.

```APIDOC
basementType Key:
  Maps basement configuration codes to their descriptions.
  Parameters:
    Code: The single-letter identifier for the basement type.
    Description: A textual description of the basement type.
  Example Mappings:
    A: Above-Grade Basement
    B: Bi-Level (Split Entry)
    C: Cellar
    Z: Zero Entry Basement
```

--------------------------------

### API Rate Limits

Source: https://docs.realie.ai/api-reference/introduction

Information on the enforced rate limits to maintain optimal performance for all users. Exceeding the limit results in a specific error response.

```APIDOC
Rate Limit:
  1200 requests per minute.
Error on Exceeding Limit:
  429 Too Many Requests
```

--------------------------------

### Realie Property Data API Endpoints

Source: https://docs.realie.ai/api-reference/introduction

Provides access to various property data search and lookup functionalities, including general property search, address and parcel ID lookups, owner searches, location-based queries, and premium search options for advanced analysis. Each endpoint is designed for performance and flexibility.

```APIDOC
GET /api-reference/property/property-search
  Description: A flexible way to paginate through large areas (such as entire counties) to collect all relevant data.
  Parameters: (Details not provided in source text, typically includes pagination, filtering, and sorting parameters)
  Returns: Property data records.
```

```APIDOC
GET /api-reference/property/address-lookup
  Description: Retrieve detailed property information quickly by specifying a known address. Optimized for lower latency, perfect for real-time applications.
  Parameters: address (string, required)
  Returns: Detailed property information for the specified address.
```

```APIDOC
GET /api-reference/property/parcel-id-lookup
  Description: Access property data using official parcel identifiers. Ideal for workflows that require government or official records.
  Parameters: parcelId (string, required)
  Returns: Property data associated with the parcel ID.
```

```APIDOC
GET /api-reference/property/owner-search
  Description: Find properties by owner name or related details, helping you identify multiple properties linked to the same entity.
  Parameters: ownerName (string, required)
  Returns: List of properties owned by the specified entity.
```

```APIDOC
GET /api-reference/property/location-search
  Description: Perform geospatial queries using latitude, longitude, and radius parameters to return properties within a specified area.
  Parameters: latitude (float, required), longitude (float, required), radius (float, required)
  Returns: Properties within the specified geographic area.
```

```APIDOC
GET /api-reference/premium/premium-owner-search
  Description: Powered by Apache Lucene, this endpoint offers advanced, flexible search capabilities, ideal for nuanced queries and partial matches.
  Parameters: (Details not provided in source text, likely includes advanced search operators)
  Returns: Advanced search results for property owners.
```

```APIDOC
GET /api-reference/premium/premium-comparables-search
  Description: Identify and compare similar properties based on factors like price, size, and location. Excellent for market trend analysis, valuations, and investment decision-making.
  Parameters: (Details not provided in source text, likely includes property attributes for comparison)
  Returns: List of comparable properties.
```

--------------------------------

### Property Mortgage and Lien Data Fields

Source: https://docs.realie.ai/api-reference/property-data-schema

Specifies the data fields related to mortgages, liens, financing history, and loan-to-value ratios for a property.

```APIDOC
totalLienCount: integer
  Description: Total Lien Count. Example: 1

totalLienBalance: float
  Description: Total Lien Balance. Example: 453664

totalFinancingHistCount: integer
  Description: Total Financing History Count. Example: 5

LTVCurrentEstCombined: float
  Description: Loan-to-Value Current Estimate. Example: 26.0742

LTVCurrentEstRange: float
  Description: Loan-to-Value Current Estimate Range. Example: 1

equityCurrentEstBal: float
  Description: Equity Current Estimate Balance. Example: 1286231

equityCurrentEstRange: float
  Description: Equity Current Estimate Range. Example: 22

LTVPurchase: float
  Description: Loan-to-Value Purchase. Example: 80

lenderName: string
  Description: Lender Name. Example: "FIRST NATIONAL BANK"

forecloseCode: string
  Description: Foreclosure Code. Example: "0111"

forecloseRecordDate: string
  Description: Foreclosure Record Date (YYYYMMDD Format). Example: "2024-01-10"
```

--------------------------------

### Premium Data API Endpoints

Source: https://docs.realie.ai/api-reference/response-codes

Access advanced property data, including premium owner information and comparable sales data for market analysis.

```APIDOC
Premium Owner Search:
  GET /api-reference/premium/premium-owner-search
  Description: Retrieves enhanced owner information for properties.
  Parameters:
    - owner_name: The name of the property owner.
    - address: Optional, to refine search by address.
  Returns:
    - Array of property objects with premium owner details.

Premium Comparables Search:
  GET /api-reference/premium/premium-comparables-search
  Description: Finds comparable properties for valuation and market analysis.
  Parameters:
    - property_id: The ID of the property for which to find comparables.
    - comparable_criteria: Filters for comparables (e.g., square footage, year built).
  Returns:
    - Array of comparable property objects.
```

--------------------------------

### floorType Key Mappings (APIDOC)

Source: https://docs.realie.ai/api-reference/feature-key

Defines the mapping between single-letter codes and descriptions for various floor types. This is used to categorize the interior flooring material of a building.

```APIDOC
floorType Key:
  Maps interior flooring codes to their descriptions.
  Parameters:
    Code: The single-letter identifier for the floor type.
    Description: A textual description of the flooring material.
  Example Mappings:
    A: Asphalt Tile
    B: Bamboo Flooring
    C: Ceramic Tile
    Z: Zinc or Metal Floor Panels
```

--------------------------------

### Unit Number Normalization (Python)

Source: https://docs.realie.ai/code-references

This Python utility cleans raw unit information by removing common designators such as apartment, basement, suite, and their abbreviations in a case-insensitive way. It dynamically builds a regular expression from a mapping of full words and abbreviations, strips out any matches, then trims whitespace to return only the core unit identifier.

```Python
import re

unit_designators_mapping = {
    "APARTMENT": "APT",
    "BASEMENT": "BSMT",
    "BUILDING": "BLDG",
    "DEPARTMENT": "DEPT",
    "FLOOR": "FL",
    "FRONT": "FRNT",
    "HANGER": "HNGR",
    "KEY": "KEY",
    "LOBBY": "LBBY",
    "LOT": "LOT",
    "LOWER": "LOWR",
    "OFFICE": "OFC",
    "PENTHOUSE": "PH",
    "PIER": "PIER",
    "REAR": "REAR",
    "ROOM": "RM",
    "SIDE": "SIDE",
    "SLIP": "SLIP",
    "SPACE": "SPC",
    "STOP": "STOP",
    "SUITE": "STE",
    "TRAILER": "TRLR",
    "UNIT": "UNIT",
    "UPPER": "UPPR",
    "#": "NUMBER"
}

# build sets of all designators (full words and abbreviations)
all_designators = set(unit_designators_mapping.keys()) | set(unit_designators_mapping.values())

# split into word-only vs symbol-containing
word_designators = [d for d in all_designators if re.match(r'^\w+$', d)]
symbol_designators = [d for d in all_designators if not re.match(r'^\w+$', d)]

# build two sub-patterns: one with \b...\b for word-designators, one raw for symbols
parts = []
if word_designators:
    parts.append(r"\b(?:" + "|".join(re.escape(d) for d in word_designators) + r")\b")
if symbol_designators:
    parts.append("|".join(re.escape(d) for d in symbol_designators))

# final pattern matches either case
unit_identifiers = r"(?:" + "|".join(parts) + r")"

def normalize_unit_number(unit_info: str) -> str:
    """
    Remove known designators (case-insensitive), then trim whitespace.
    """
    return re.sub(unit_identifiers, "", unit_info, flags=re.IGNORECASE).strip()

# example usage
if __name__ == "__main__":
    print(normalize_unit_number("Apartment 12B"))   # "12B"
    print(normalize_unit_number("#300"))           # "300"
    print(normalize_unit_number("# 300"))          # "300"
    print(normalize_unit_number("number 300"))     # "300"
    print(normalize_unit_number("Unit 12A"))       # "12A"
    print(normalize_unit_number("Suite 100"))      # "100"
    print(normalize_unit_number("Apt 5"))          # "5"
    print(normalize_unit_number("BSMT 1"))         # "1"
    print(normalize_unit_number("FL 3"))           # "3"
    print(normalize_unit_number("PH 2"))           # "2"
    print(normalize_unit_number("TRLR 4"))         # "4"
    print(normalize_unit_number("123"))            # "123" (no change)
    print(normalize_unit_number("  "))             # "" (empty string)

```

--------------------------------

### Realie Property Data API Endpoints

Source: https://docs.realie.ai/api-reference/faq

This section details various endpoints available in the Realie Property Data API for retrieving property information. It covers searching by address, parcel ID, owner, and location, along with premium search options.

```APIDOC
Property Search Endpoint:
  - Purpose: Retrieves properties matching a query, potentially returning multiple results.
  - Usage: Recommended for queries where multiple properties might match.
  - Related: Address Lookup Endpoint (for individual queries), Parcel ID Lookup, Owner Search, Premium Owner Search, Location Search.

Address Lookup Endpoint:
  - Purpose: Provides quicker results for individual address queries.
  - Usage: Preferred for single address lookups.
  - Related: Property Search Endpoint.

Parcel ID Lookup:
  - Purpose: Retrieves property details using a specific Parcel ID.
  - Related: Property Search Endpoint, Owner Search, Premium Owner Search, Location Search.

Owner Search Endpoint:
  - Purpose: Searches for properties associated with an owner's name.
  - Limitations: Looks for exact matches, may miss results due to non-standard owner name formatting.
  - Related: Premium Owner Search Endpoint.

Premium Owner Search Endpoint:
  - Purpose: Enhanced owner search leveraging Apache Lucene and custom filtering for more accurate results.
  - Usage: Recommended when the basic Owner Search Endpoint fails to return correct properties.
  - Related: Owner Search Endpoint.

Location Search:
  - Purpose: Retrieves properties within a specified geographic location.
  - Pagination: Requires pagination to retrieve all results for a location.
  - Related: Property Search Endpoint, Parcel ID Lookup, Owner Search, Premium Owner Search.

API Data Format:
  - Structure: Returns data in a JSON format.
  - Sections:
    - `data`: An array of property objects.
    - `metadata`: An object containing pagination details (`limit`, `offset`, `count`).

Pagination:
  - Mechanism: Results are paginated, requiring multiple requests to retrieve all data for a location.
  - Parameter: Adjust the `limit` parameter to control the number of parcels returned per request (up to 100).
  - Example: Refer to the Code Reference Library Page for pagination examples.
```

--------------------------------

### Premium Owner Search API Endpoint

Source: https://docs.realie.ai/api-reference/premium/premium-owner-search

This snippet demonstrates how to perform a premium owner search using the Realie Property Data API. It includes the cURL command for making the request and the expected JSON response structure.

```APIDOC
GET /public/premium/owner/

Our advanced owner search incorporates Apache Lucene and custom filtering to find the correct owner each time, regardless of variations in name, formatting, or other variations.
We recommend to use this endpoint to find the correct owner name formatting, then use the basic owner search to find the rest of the owner’s portfolio.

Parameters:
- Authorization (string, header, required): Provide your API key directly in the header.
- state (string, query, required): The state (e.g. CA) where the property is located.
- lastName (string, query, required): The last name of the property owner (or the company name).
- county (string, query, optional): The county where the property is located.
- firstName (string, query, optional): The first name of the property owner.
- limit (integer, query, optional, default:25): Maximum number of results to return. Defaults to 25, maximum is 25. Required range: 1 <= x <= 25.
- offset (integer, query, optional, default:0): Number of records to skip. Defaults to 0. Required range: x >= 0.

Response (200 OK):
Content-Type: application/json

{
  "properties": [
    {}
  ],
  "metadata": {
    "limit": 123,
    "count": 123
  }
}

Error Responses:
- 400: Bad Request
- 401: Unauthorized
- 403: Forbidden
- 404: Not Found
- 500: Internal Server Error
```

```curl
curl --request GET \
  --url https://app.realie.ai/api/public/premium/owner/ \
  --header 'Authorization: <api-key>'
```

--------------------------------

### garageType Key Mappings (APIDOC)

Source: https://docs.realie.ai/api-reference/feature-key

Defines the mapping between single-letter codes and descriptions for different garage types. This is used to categorize the parking structure associated with a property.

```APIDOC
garageType Key:
  Maps garage type codes to their descriptions.
  Parameters:
    Code: The single-letter identifier for the garage type.
    Description: A textual description of the garage type.
  Example Mappings:
    A: Attached Garage
    B: Basement Garage
    C: Carport
    Z: Zoned Permit Parking
```