> ## Knowledge Base Index
> Fetch the complete knowledge base index at: https://help.repliers.com/sitemap.xml
> Use this file to discover available pages before exploring further.
> Pure-Markdown content can be obtained by appending a '.md' suffix to the content URLs listed in the sitemap (without the trailing slash).

# Using the LiveBy Data Add-on for Boundaries, Demographics, and Schools

## Overview

The Repliers LiveBy Data Add-on lets you add geographic boundaries, community demographics, and school information to your real estate search experience. Use it to help users explore neighborhoods, find listings within a selected area, and see which locations a property belongs to.

The add-on provides three categories of data:

| Data | What you can display |
| --- | --- |
| Geographic boundaries | Outlines for neighborhoods, cities, postal codes, counties, districts, school districts, and school attendance zones. |
| Demographics | Community profiles, including population, age, income, housing, education, employment, and commuting information. |
| Schools | School details, grade ranges, programs, attendance zones where available, enrollment history, and performance rankings. |

Each LiveBy location has a `locationId`. You can use that ID to retrieve the location's details, filter MLS® listings, or request market statistics for the same area. You can also work in the opposite direction: retrieve a listing and include the locations it falls within.

[Watch the LiveBy Data Add-on walkthrough](https://www.youtube.com/watch?v=2UTWtodhMyQ) to see neighborhood and postal code layers, school attendance zones, community insights, and a listing reverse lookup in action.

**Note:** These are geographic-area and school attendance boundaries, not individual property lot lines.

## Before You Begin

You'll need a Repliers API key with the LiveBy Data Add-on enabled. Contact our team to confirm access for your account. You can also explore sample LiveBy data in the [Developer Playgrounds](https://playgrounds.repliers.com/).

The examples below call the Repliers API directly. Include your API key in the request header:

```
REPLIERS-API-KEY: YOUR_API_KEY
```

For authentication guidance, see our [API Authentication Guide](https://help.repliers.com/en/article/repliers-api-authentication-guide-1pmm1p2/). Replace placeholders such as `{locationId}`, `{mlsNumber}`, and `{boardId}` with values from your own responses. Sample IDs and response excerpts are illustrative, not a fixed set of production locations or current market figures.

## How LiveBy Locations Work

LiveBy data extends our Locations API. Use `GET /locations` to retrieve locations and `GET /locations/autocomplete` to find them as a user types.

Set `source=LiveBy` to restrict a locations request to the add-on's data:

```
GET https://api.repliers.io/locations?source=LiveBy
```

When `source` is omitted, results can include other location sources available to your key, including MLS®-defined locations. MLS® locations generally don't include boundary geometry and don't carry LiveBy demographic or school data. Check the `source` field rather than relying on a record's name alone.

### Understanding the Location Record

| Field | How to use it |
| --- | --- |
| `locationId` | Identify the location, retrieve it again, and use it in listing and statistics requests. |
| `name` | Display the location's name. |
| `type` | Identify a neighborhood, city, school, or another supported location type. |
| `source` | Identify the provider. LiveBy records use `LiveBy`. |
| `liveById` | LiveBy's internal identifier for the location. Use `locationId` for the Repliers workflows in this article. |
| `mlsId` | Numeric identifier of the MLS® associated with the location. |
| `size` | Area of the boundary in square kilometers. |
| `address` | Location hierarchy, including country, state, area or county, city, and neighborhood. |
| `map` | The location's center point and boundary geometry, where available. |
| `demographics` | The community profile for location types other than `school`. |
| `school` | School details when `type=school`. |

`classification` and `subType` are `null` on LiveBy records. These fields apply to other location sources.

**Important:** A `school` location and a `schoolDistrict` location are different records. A school returns a `school` object and `demographics: null`. A school district returns a community profile in `demographics`; its `school` object is `null`.

### Pagination

Locations responses include `page`, `numPages`, `pageSize`, `count`, and a `locations` array. `resultsPerPage` accepts 1–300 and defaults to 100.

Use the pagination information when loading a map layer or collecting a set of locations. Don't treat the first page as the complete result set. For the shared location model and full query-parameter reference, see our [Locations API Implementation Guide](https://help.repliers.com/en/article/locations-api-implementation-guide-s4c68b/).

## Displaying Geographic Boundaries on a Map

### Step 1: Choose a Location Type

Use `type` to select the layer your user wants to explore:

| Type | Description |
| --- | --- |
| `neighborhood` | A neighborhood within a city. |
| `neighborhood-alternate` | An alternate representation of a neighborhood. |
| `city` | A municipal division. |
| `city-alternate` | An alternate representation of a city. |
| `postalCode` | A postal code area, such as a ZIP code in the United States. |
| `area` | A larger regional division, such as a county or parish. |
| `district` | An administrative or political district. |
| `schoolDistrict` | A school district boundary. |
| `school` | An individual school, including its attendance zone where one is assigned. |

`type` accepts multiple values. For example:

```
GET https://api.repliers.io/locations?source=LiveBy&type=neighborhood&type=school
```

**Note:** Alternate neighborhood and city types can overlap their primary types. Use the primary type for a map layer when you don't want two representations of the same place outlined together. Alternate types can still be useful in search, where a user may enter an alternate name.

### Step 2: Request the Boundaries

This request retrieves LiveBy neighborhoods in Austin and selects the fields needed to draw and identify them:

```
GET https://api.repliers.io/locations?source=LiveBy&city=Austin&type=neighborhood&hasBoundary=true&resultsPerPage=100&fields=locationId,name,type,map.latitude,map.longitude,map.geometryType,map.boundary
```

`hasBoundary=true` limits results to locations with a polygon. The `fields` selection keeps the map request focused on geometry rather than loading every location's demographic profile.

Changing `type` changes the layer. Use `type=postalCode` for postal code outlines, `type=area` for county-level areas, or `type=schoolDistrict` for school district boundaries.

### Step 3: Render and Select a Boundary

Use `map.geometryType` and `map.boundary` together to create the shape in your map renderer:

| Map field | Format |
| --- | --- |
| `latitude` and `longitude` | Center-point coordinates returned as strings. Convert them to numbers when your map library requires numeric values. |
| `point` | A WKT center point in the form `POINT (longitude latitude)`. |
| `geometryType` | `Polygon` or `MultiPolygon`. |
| `boundary` | Coordinate arrays in `[longitude, latitude]` order, using the WGS 84 and GeoJSON convention. |

A `Polygon` boundary contains rings, points, and coordinate pairs. A `MultiPolygon` adds an outer level containing the individual polygons. Preserve that structure rather than flattening the arrays or assuming every location is a single polygon.

Keep the `locationId` associated with each rendered shape. When a user selects a boundary, highlight it, move the map to the selected area, and retrieve the information needed for your details panel:

```
GET https://api.repliers.io/locations?source=LiveBy&locationId={locationId}
```

You can then use the same ID to load listings and market statistics, as described below.

## Finding Locations Around a Point or Search Area

### Find Boundaries That Contain a Point

Use `pointWithinBoundary=true` to find the LiveBy boundaries that contain a coordinate:

```
GET https://api.repliers.io/locations?source=LiveBy&lat=30.2500&long=-97.7700&pointWithinBoundary=true
```

The results can include different levels of geography at the same point, such as a neighborhood, city, and county. Add a `type` filter when you only need one category.

This is a containment lookup, not a proximity search.

### Search Around a Coordinate

The Locations API also supports a radius search:

```
GET https://api.repliers.io/locations?source=LiveBy&lat=30.2742&long=-97.7507&radius=5
```

Use radius search for proximity-based browsing, and containment when the question is which boundary includes the coordinate. See the [Locations API Implementation Guide](https://help.repliers.com/en/article/locations-api-implementation-guide-s4c68b/) for the shared spatial-filter definitions and distance units.

### Search Within a Polygon

Use `map` to supply a search polygon:

```
GET https://api.repliers.io/locations?source=LiveBy&type=neighborhood&map=[[[-97.80,30.22],[-97.72,30.22],[-97.72,30.28],[-97.80,30.28],[-97.80,30.22]]]
```

The polygon is shown before URL encoding; encode the query parameters when building the request. Coordinates must use `[longitude, latitude]` order, and the polygon must be closed: its final coordinate must match its first coordinate. For large polygons, use the POST method and send `map` in the request body.

The request's `map` parameter describes the area being searched. Each returned location's `map.boundary` describes that individual location's shape.

### Filter by Boundary Size

Use `minSize` and `maxSize` to restrict the area of returned boundaries:

```
GET https://api.repliers.io/locations?source=LiveBy&type=neighborhood&minSize=1&maxSize=5
```

Both parameters use square kilometers, matching the location's `size` field.

## Building Location Autocomplete

Use [Locations autocomplete](https://docs.repliers.io/reference/get_locations-autocomplete) to help users find LiveBy places as they type:

```
GET https://api.repliers.io/locations/autocomplete?search=Barton&source=LiveBy&fields=locationId,name,type,address
```

Matching is relevance-based and supports partial input and spelling mistakes. The selected result connects directly to the boundary, demographic, or school record through its `locationId`.

| Setting | Behavior |
| --- | --- |
| `search` | Required; accepts 3–100 characters. |
| `resultsPerPage` | Accepts 1–10 and defaults to 10. |
| `boundary` | Boundaries are excluded by default. Set `boundary=true` to include them. |
| `fields` | Limits the returned fields. Without field selection, autocomplete returns the location's full non-boundary data, including applicable demographic or school details. |

Display lightweight suggestions first. When a user selects a result, use its `locationId` to retrieve the boundary and insights you need, then focus the map and load listings for that area.

To include geometry in the autocomplete response itself, set `boundary=true` and include `map.geometryType` and `map.boundary` in your field selection. A result without a polygon may still represent a valid location, particularly a school without an attendance zone.

**Tip:** Debounce autocomplete requests by 200–300 milliseconds and request only the fields displayed in the suggestions.

## Finding Listings and Market Statistics Within a Boundary

### Listing Search

Pass the selected LiveBy `locationId` to the listings endpoint:

```
GET https://api.repliers.io/listings?locationId={locationId}
```

This lets you connect a neighborhood outline, postal code, or another selected boundary to the MLS® listings within it. You can keep your usual listing filters available while the user explores that area.

In the example application, selecting Downtown Houston highlights the boundary and displays listing markers inside it. The user can then change listing filters, such as showing properties for sale rather than for lease, without choosing a different area.

### Market Statistics

Use the same ID for a statistics request:

```
GET https://api.repliers.io/listings?locationId={locationId}&listings=false&statistics=avg-listPrice,cnt-available
```

`listings=false` omits the listing records when you only need the statistics. This example requests the average list price and the count of available listings. Monthly grouping is available with `grp-mth` when configuring a grouped statistic.

**Important:** Market statistics and community demographics are different datasets. Market statistics come from listing data filtered to the selected area. LiveBy demographics describe the community. For example, `demographics.medianHouseValue` is not the same measure as an average listing price or a median sold price.

The example application keeps these views separate with **Demographics** and **Market Stats** tabs. Use clear measure names and reporting periods in your own interface as well.

### AI Listing Search

LiveBy locations also work with AI listing search. When a natural-language request names a place, such as “listings in Downtown Houston,” the AI listing search can resolve that place to a `locationId` for the listings request that follows.

This connects typed location search, map selection, and natural-language search to the same location-based workflow.

## Displaying Demographic Data

LiveBy locations other than `school` return a community profile in `demographics`. This includes neighborhoods, cities, postal codes, counties or other areas, districts, and school districts.

An abbreviated demographic record can look like this:

```json
{
  "population": 8957,
  "populationDensity": 3850.07,
  "populationDensityUnit": "m",
  "medianAge": 35,
  "medianIncome": 103582,
  "medianHouseValue": 882758,
  "confidence": 11.83,
  "jobType": {
    "blueCollar": 266,
    "whiteCollar": 6061
  },
  "metadata": {
    "source": "US",
    "attribution": "American Census Survey 2023"
  }
}
```

This is a sample excerpt; additional breakdowns are described below. Read attribution and reporting context from the returned data rather than hard-coding the example year.

### Summary Fields

| Field | Description |
| --- | --- |
| `population` | Total population. |
| `populationDensity` | Population density, with its unit identified by `populationDensityUnit`. |
| `populationDensityUnit` | Unit indicator for population density. |
| `medianAge` | Median age. |
| `medianIncome` | Median household income. |
| `medianHouseValue` | Median house value. |
| `medianRentMonthlyCost` | Median monthly rent. |
| `medianMortgageMonthlyCost` | Median monthly mortgage cost. |
| `percentMale` / `percentFemale` | Gender split, expressed as percentages. |
| `countMarried` / `countUnmarried` | Married and unmarried counts. |
| `averageHouseholdSize` | Average people per household. |
| `averageRooms` | Average rooms per dwelling. |
| `averageTravelTime` | Average commute time. |
| `privateHouseholds` | Number of private households. |
| `householdsWithChildren` | Households with children. |
| `annualResidentialTurnover` | Annual residential turnover. |
| `educationClimateIndex` | Composite education index. |
| `confidence` | Numeric confidence score associated with the estimates. |

### Breakdown Objects

The `demographics` object also includes the following breakdowns:

| Object | Available keys or bands |
| --- | --- |
| `age.byCohort` | 18 age cohorts, from `between0To4` through `between85AndOver`. |
| `age.byLifeStage` | `between0To9`, `between10To17`, `between18To24`, `between25To64`, `between65To74`, `between75AndOver`. |
| `income.byLevel` | 6 bands, from `between0To25000` through `over100000`. |
| `income.byCohort` | 16 bands, from `between0To10k` through `over200k`. |
| `homeValue` | 6 bands, from `below100000` through `above500000`. |
| `rent` | `under499`, `between500To749`, `between750To999`, `over999`. |
| `medianMortgagePayment` | 6 bands, from `under500` through `over4000`. |
| `yearBuilt` | 7 bands, from `before1970` through `after2019`. |
| `rooms` | `studio`, `oneBedroom`, `twoBedrooms`, `threeBedrooms`, `fourBedroomsOrMore`. |
| `occupancy` | `unitOccupiedOwner`, `unitOccupiedRenter`, `vacant`, `absenteeOwner`. |
| `education` | `noDegree`, `highSchool`, `collegeBelowBachelor`, `bachelor`, `master`, `doctorate`. |
| `enrollment` | `none`, `publicPrePrimarySchool`, `privatePrePrimarySchool`, `publicSchool`, `privateSchool`, `publicCollege`, `privateCollege`. |
| `maritalStatus` | `single`, `married`, `widowed`, `divorced`, `separated`. |
| `jobType` | `blueCollar`, `whiteCollar`. |
| `jobSector` | `privateWorker`, `governmentWorker`, `notForProfitWorker`, `selfEmployedWorker`, `unpaidFamilyWorker`. |
| `occupation` | `management`, `businessFinanceAdmin`, `appliedScience`, `educationLawSocialGovernment`, `artCultureSport`, `sales`, `trades`, `agriculture`, `manufacturing`, `notApplicable`. |
| `commuteTime` | `under15Minutes`, `between15To29Minutes`, `between30To59Minutes`, `over60Minutes`. |
| `transportationMode` | `carAlone`, `carCarpool`, `carDriver`, `carSelf`, `publicTransit`, `walked`, `bicycle`, `other`. |
| `metadata` | `source`, `attribution`. |

For a focused community panel, retrieve only the values it displays:

```
GET https://api.repliers.io/locations?locationId={locationId}&fields=name,demographics.population,demographics.medianAge,demographics.medianIncome,demographics.age.byLifeStage,demographics.metadata
```

### Interpreting and Presenting the Values

Breakdown values are counts unless the field name says otherwise, such as fields beginning with `percent`. Don't label raw counts as percentages. Before deriving percentages or comparing areas of different sizes, confirm the denominator for that measure; this article doesn't define one for every breakdown.

Unavailable values are returned as `null`. Treat a missing value as unavailable rather than converting it to zero.

Display `demographics.metadata.attribution` alongside the demographic information. Keep unit information associated with the figures it describes. The example's `populationDensityUnit` is reproduced as returned; confirm the unit definition before converting it into a human-readable label.

The `confidence` field is a numeric score attached to the estimates. This article doesn't define its scale, a percentage interpretation, or a recommended cutoff, so confirm its definition before using it to suppress figures or label one estimate as more reliable than another.

**Important:** Before publishing demographic or student-body composition information alongside real estate listings, have your compliance team review the intended use and presentation for applicable fair housing and display requirements.

## Displaying School Information

When `type=school`, the location returns a `school` object instead of a community demographic profile. An abbreviated school record looks like this:

```json
{
  "locationId": "SAMPLBUSTXSCDAHMAIHA",
  "type": "school",
  "name": "Manor New Technology High",
  "source": "LiveBy",
  "demographics": null,
  "school": {
    "schoolName": "Manor New Technology High",
    "schoolType": "public",
    "schoolLevel": "High",
    "lowGrade": "09",
    "highGrade": "12",
    "districtName": "Manor Independent School District",
    "schoolDistrictLocationId": "LBUSTXSDODFAEEOP",
    "phone": "5122784875",
    "website": "https://newtechhigh.manorisd.net/",
    "isAssigned": true,
    "isCharterSchool": false,
    "giftedAndTalented": true,
    "dualEnrollment": true,
    "apCourse": true
  }
}
```

The excerpt omits map data, additional school fields, and metrics for readability.

### School Details

| Field | Description |
| --- | --- |
| `schoolName` | School name. |
| `schoolType` | `public` or `private`. |
| `schoolLevel` | `Elementary`, `Middle`, `High`, or `Private`. |
| `lowGrade` / `highGrade` | Grade range, using strings such as `"05"` and `"12"`. |
| `districtName` | School district name. |
| `schoolDistrictLocationId` | Repliers `locationId` for the corresponding school district. |
| `phone` | Contact number, returned without formatting. |
| `website` | School website. |
| `isAssigned` | Whether the school has an assigned attendance zone. |
| `isPrivate`, `isCharterSchool`, `isMagnetSchool`, `isVirtualSchool` | School classification flags. |
| `isTitleISchool`, `isTitleISchoolwideSchool` | Title I designation. |
| `isJJFacility` | Juvenile justice facility indicator. |
| `apCourse`, `apEnrollment` | Advanced Placement course and enrollment information. |
| `internationalBaccalaureate`, `dualEnrollment`, `creditRecovery` | Program availability. |
| `giftedAndTalented`, `interscholarAthletics`, `singleSexClasses` | Program availability. |
| `offersKindergarten`, `offersFullDayKindergarten` | Kindergarten availability. |
| `expenditurePerStudent` | Spending per student. |
| `privateSchoolAffiliation` | Private school affiliation, such as `Nonsectarian`. |
| `privateCoed`, `privateDays`, `privateHours`, `privateHasLibrary` | Additional private school attributes. |
| `metrics` | Performance and enrollment history. |

Public and private schools populate different subsets of these fields. Private schools return `null` for many public-school reporting fields, while public schools return `null` for the `private*` fields. Keep the difference between `false` and `null`: an unavailable value shouldn't be displayed as a confirmed “No.”

### Attendance Zones

A school location includes a boundary polygon where the school has an assigned attendance zone. Schools without a zone can return only a center point; some return no `map` object at all. This is common for private, charter, magnet, and virtual schools, but don't assume boundary availability from the school classification alone.

To draw only schools with attendance-zone geometry:

```
GET https://api.repliers.io/locations?source=LiveBy&type=school&hasBoundary=true&fields=locationId,name,map.geometryType,map.boundary,school.schoolLevel
```

A nearby school is not necessarily a school whose attendance zone contains the property. Use boundary containment or the listing reverse lookup when you need that geographical relationship.

### Filtering Schools

These parameters apply when `type=school` and accept multiple values:

| Parameter | Values or purpose |
| --- | --- |
| `schoolType` | `public` or `private`. |
| `schoolLevel` | `Elementary`, `Middle`, `High`, or `Private`. |
| `schoolDistrictName` | Filter by school district name. |
| `privateSchoolAffiliation` | Filter private schools by affiliation. |

For example, retrieve public elementary schools:

```
GET https://api.repliers.io/locations?source=LiveBy&type=school&schoolLevel=Elementary&schoolType=public
```

### School Performance

`school.metrics.rankHistory` contains one entry per ranked year. For example:

```json
{
  "year": 2025,
  "rank": 1632,
  "rankOf": 1974,
  "rankStars": 1,
  "rankLevel": "High"
}
```

| Field | Description |
| --- | --- |
| `year` | Year the ranking applies to. |
| `rank` | The school's position in the comparison set. |
| `rankOf` | Total number of schools in that set. |
| `rankStars` | Normalized 1–5 rating. |
| `rankLevel` | The comparison group, such as `High`. |

Show the ranking year and comparison group with the result. `rankHistory` can be empty, and private schools generally don't have a ranking. An empty ranking history is not a zero rating.

### Enrollment History

`school.metrics.schoolYearlyDetails` contains one entry per reporting year:

| Field | Description |
| --- | --- |
| `year` | Reporting year. |
| `numberOfStudents` | Total enrollment. |
| `teachersFulltime` | Full-time teaching staff. |
| `pupilTeacherRatio` | Students per teacher. |
| `percentFreeDiscLunch` | Percentage receiving free or discounted lunch. |
| `numberof*Students` / `percentof*Students` | Student-body composition, as counts and percentages. |

**Note:** Preserve the exact field casing. `numberOfStudents` uses a capital `Of`, while composition fields use a lowercase `of`, such as `numberofAsianStudents`.

Student-body composition fields require the same display review described in the demographics section. Select the school details your interface needs rather than automatically publishing every returned field.

### Connecting a School to Its District

Use `school.schoolDistrictLocationId` to retrieve the related school district:

```
GET https://api.repliers.io/locations?locationId={schoolDistrictLocationId}&fields=locationId,name,size,map.geometryType,map.boundary,demographics
```

The district location provides its boundary, area, and community demographics. It doesn't contain the individual school's `school` object.

To retrieve schools by district name:

```
GET https://api.repliers.io/locations?source=LiveBy&type=school&schoolDistrictName=Manor%20Independent%20School%20District
```

See the sandbox note under Troubleshooting when a district ID from a sample school doesn't resolve.

## Adding Location Context to a Listing Page

Add `locations=true` to a single-listing request to include the locations that contain the listing:

```
GET https://api.repliers.io/listings/{mlsNumber}?boardId={boardId}&locations=true
```

The response includes a `locations` array. The following excerpt shows the kinds of entries it can contain; full detail objects are omitted:

```json
{
  "locations": [
    {
      "source": "MLS",
      "type": "neighborhood",
      "name": "Barton Hills",
      "resource": "Property:2505"
    },
    {
      "source": "LiveBy",
      "type": "neighborhood",
      "name": "Barton Hills"
    },
    {
      "source": "LiveBy",
      "type": "school",
      "name": "Cedar Creek Elementary"
    },
    {
      "source": "LiveBy",
      "type": "area",
      "name": "Travis County"
    },
    {
      "source": "LiveBy",
      "type": "city",
      "name": "Austin"
    }
  ]
}
```

Use these records to add neighborhood, postal code, county, city, school district, and school context alongside the listing's photos and description. The lookup handles the geographical matching for you, so your application doesn't need to geocode the address or run its own point-in-polygon checks.

**Important:** Check `source` and `type` on each entry. MLS® and LiveBy records can use the same place name, and the array doesn't have a guaranteed order. Choose the record that fits the view instead of displaying duplicate labels or assuming the first item is the neighborhood. LiveBy records contain their applicable demographic or school data; an MLS® record doesn't become a LiveBy profile because it shares a name.

A school is included through this containment lookup when the listing falls within its assigned attendance zone. This is not a list of every nearby school.

You can also make the returned location cards interactive. In the example application, selecting the listing's postal code opens that boundary on the map and loads listings within it. Keep each record's `locationId` so that transition is possible.

For a coordinate-based version of this lookup, use `pointWithinBoundary=true` on `/locations`. For the listing request reference, see [Get a listing](https://docs.repliers.io/reference/get-a-listing).

## Building Filters with Aggregates

Use `aggregates` to retrieve distinct values and counts across the matching LiveBy locations. This is useful for populating filter controls with values that exist in the result set:

```
GET https://api.repliers.io/locations?source=LiveBy&locations=false&aggregates=type,school.schoolLevel,school.districtName
```

This requests counts by location type, school level, and district name. Aggregates respect the request's other filters. For example:

```
GET https://api.repliers.io/locations?source=LiveBy&city=Austin&type=school&aggregates=school.schoolType&locations=false
```

`locations=false` skips the individual location records when you only need the aggregate information.

Aggregate bucket totals don't always equal the top-level `count`; use `count` for the total number of matching locations. `classification` and `subType` return empty aggregate objects for LiveBy records because those fields are `null`. Unsupported aggregate fields return an error; use the supported fields listed in the [Locations API Implementation Guide](https://help.repliers.com/en/article/locations-api-implementation-guide-s4c68b/).

These aggregates describe location records. They are separate from the listing-derived market statistics discussed earlier.

## Testing in the Developer Playgrounds

You can explore the data and inspect generated requests before building your interface:

1. Open the [Developer Playgrounds](https://playgrounds.repliers.com/), select **Locations**, and choose the `locations` endpoint. Set `source` to `LiveBy` and `type` to `neighborhood`. Move the map to an area to inspect its boundaries and response data.
2. Select a boundary and review its `locationId`, `map`, and `demographics`. Change `type` to `postalCode`, `schoolDistrict`, or `school` to explore another layer. For schools, inspect `school` rather than expecting demographics.
3. Use the selected `locationId` in **Listing Search** or **Statistics**. To test typed place search, return to **Locations**, choose `locations/autocomplete`, and enter a search term.
4. Open a listing in the **Listing** view and set `locations` to `true`. Inspect the returned `locations` array alongside the listing information.

The [walkthrough video](https://www.youtube.com/watch?v=2UTWtodhMyQ) uses Houston to show neighborhood and postal code layers, school attendance boundaries, community insights, and a listing reverse lookup. Your own results depend on the data available to the API key and the filters in the request.

## Using the Open-Source Example

Our [LiveBy proof of concept](https://github.com/Repliers-io/liveby-poc) demonstrates how these pieces can work together in one map-based experience.

The application shown in the [walkthrough](https://www.youtube.com/watch?v=2UTWtodhMyQ) includes layer controls for counties, cities, neighborhoods, postal codes, school districts, and schools. Selecting an area highlights its shape, shows listings within it, and opens an insights panel. The panel separates demographic information from market statistics.

Opening a listing adds location cards with boundary previews. Users can select a card to explore that geography, adjust listing filters, or use autocomplete to move to another place.

Fork or clone the repository, follow its setup instructions, and configure your Repliers API key with the required data access. Use it as a starting point for your own application. The example's map styling, colors, panels, and navigation are interface choices, not API requirements.

## Keeping Responses Focused

### Request Only the Fields a View Needs

Full LiveBy responses can include large boundary arrays and detailed demographic or school objects. Use `fields` with dot notation to select the values required by each view:

```
GET https://api.repliers.io/locations?source=LiveBy&type=neighborhood&fields=locationId,name,address
GET https://api.repliers.io/locations?source=LiveBy&type=neighborhood&hasBoundary=true&fields=locationId,name,map.geometryType,map.boundary
GET https://api.repliers.io/locations?locationId={locationId}&fields=name,demographics
GET https://api.repliers.io/locations?source=LiveBy&type=school&fields=locationId,name,school.schoolLevel,school.metrics.rankHistory
```

Each of these serves a different task: list display, map rendering, a selected community profile, and a school summary. You don't need every field for every task.

### Load Details After Selection

Use lightweight results for lists and autocomplete. Load geometry or the full insight record when the user selects a location. Keep the selected `locationId` available so that map, listing, and details views refer to the same record.

### Reuse Boundary Geometry

Cache or reuse boundaries by `locationId` instead of fetching the same polygon on every map render. Set a refresh policy that fits your application's data-use requirements rather than treating a cached boundary as permanent.

### Control Result Volume

Use relevant geographic filters and a suitable `resultsPerPage`. Load further pages as needed, and set `locations=false` when requesting only counts or aggregates. Smaller field selections and result sets keep initial map and search interactions focused.

## Troubleshooting

### No LiveBy Locations Are Returned

- Check that the key has access to the add-on
- Confirm `source=LiveBy` is set
- Review the geographic and type filters; an empty result for one filtered query doesn't mean the key has no LiveBy access

### MLS® Locations Appear Alongside LiveBy Locations

- Add `source=LiveBy` to `/locations` or `/locations/autocomplete`; without that filter, other available sources can be returned
- In the unfiltered listing reverse lookup shown in this article, inspect `source` on each returned entry before display

### A Location Has No Demographics

- Check `type` first: individual schools return `demographics: null` and provide school information in `school`
- Check whether your `fields` selection omitted `demographics` or the nested values your panel uses

### A School District Has No School Details

- A `schoolDistrict` is a geographic record with a community profile, not an individual school
- Query `type=school` for school details, or use `schoolDistrictName` to retrieve the schools associated with the district

### Boundary Polygons Are Missing

- Not every location has a boundary; schools without an assigned attendance zone may have only a center point, or no map data
- Use `hasBoundary=true` when a drawable polygon is required
- For autocomplete, request `boundary=true` as well, and make sure `fields` includes the required map fields

### Boundaries Render Incorrectly

- Confirm `[longitude, latitude]` coordinate order
- Preserve the nesting specified by `map.geometryType`; a `MultiPolygon` has an extra level compared with a `Polygon`
- Convert center-point latitude and longitude strings to numbers where your renderer requires it

### A Location Appears Twice

- Check whether the results include both primary and alternate location types, or both MLS® and LiveBy records
- Use the source and type filters that fit the interface
- Don't assume that two records with the same display name are interchangeable

### A School District ID Does Not Resolve in the Sandbox

- Sandbox location IDs can have a `SAMPL` prefix, while cross-reference values such as `schoolDistrictLocationId` aren't always rewritten to match; this can cause an empty district lookup even when the sample school contains a district reference
- Verify the relationship using a production key with access to the data
- To retrieve the district's schools in either environment, you can also filter by `schoolDistrictName`; this is a school query, not a replacement lookup for the district's boundary record

### School Fields or Rankings Are Empty

- Some fields apply only to public or private schools, and rankings may be unavailable
- Treat `null` and empty histories as unavailable; don't display them as zero, a zero-star rating, or a confirmed “No”

### The Map Shows Fewer Locations Than Expected

- Check the requested area, selected types, `hasBoundary`, and pagination
- The default locations page contains up to 100 records; autocomplete has a separate limit of 10 suggestions
- Don't treat either first response as a complete list of every place in the area

### Responses Are Large or Slow

- Review `fields`, reduce the result count, and separate map geometry from detail loading
- Avoid downloading every community profile or complete school record just to draw a map layer
- Use `locations=false` when individual records aren't needed

## What questions does this article answer?

- What does the LiveBy Data Add-on provide, and how do I access it?
- How do I display geographic boundaries and use them for listing search, statistics, and autocomplete?
- What demographic and school information can I retrieve, and how should I interpret the response fields?
- How do I find the locations and school attendance zones associated with a listing?
- Where can I test the data, find an example application, and troubleshoot missing or oversized responses?