REAP CRM API Integration for WordPress & SaaS | GraphQL Property Sync

REAP CRM API Integration for WordPress & SaaS: Connect Property Listings Using GraphQL

If your real estate agency uses REAP CRM and you want to connect your property listings to a WordPress website, Laravel application, custom PHP platform, mobile app, or SaaS property portal, a custom REAP CRM API integration can automate the entire property data workflow.

Instead of manually entering properties into your website, developers can use the REAP Elastic GraphQL API to retrieve property listings synchronized from REAP CRM and use that data to power property searches, property detail pages, featured listings, agent pages, location filters, images and other real estate website functionality.

The documented architecture is straightforward:

REAP CRM
    ↓
Elastic GraphQL API
    ↓
Custom Integration / WordPress Plugin / SaaS
    ↓
Property Database
    ↓
Website / Portal / Mobile App

This makes REAP CRM API integration particularly useful for agencies and developers that need a custom real estate website, WordPress property integration, property synchronization system, or SaaS platform without manually managing every listing.

---

What Is REAP CRM API Integration?

A REAP CRM API integration connects a website or application to the Elastic GraphQL API used to access property listing data synchronized from REAP CRM.

The documented workflow is:

REAP CRM → Elastic → Your Website

REAP CRM synchronizes eligible properties into Elastic, while the website or application queries the Elastic GraphQL API to retrieve the required property information.

The API can be used for:

• Property listing pages
• Property search
• Property detail pages
• Featured property sections
• Property filters
• Agent information
• Locality filters
• Property category filters
• Property images
• Incremental property synchronization
• Custom real estate portals
• WordPress property websites
• Custom SaaS applications

The main property search operation is properties, while companion operations include featuredProperties, localities, categories, and agents.

---

REAP Elastic GraphQL API Endpoint

The production GraphQL endpoint documented for the integration is:

https://elastic-api.isb-software.co.uk/api/graphql

Requests are sent using HTTP POST with a JSON GraphQL body.

Required API Request Headers

POST https://elastic-api.isb-software.co.uk/api/graphql
Content-Type: application/json
X-System-Identifier: YOUR_SYSTEM_IDENTIFIER

According to the supplied API documentation, public property listing queries do not require a Bearer token. The important integration value is the X-System-Identifier header, which identifies and scopes the request to the appropriate agency or tenant system.

---

How REAP CRM Property API Integration Works

A typical REAP CRM website or SaaS integration follows a simple process:

1. Obtain the required X-System-Identifier.
2. Connect the application to the REAP Elastic GraphQL endpoint.
3. Send GraphQL queries using HTTP POST.
4. Retrieve property listings through the properties operation.
5. Apply filters such as sale/rent, price, bedrooms, bathrooms, locality and category.
6. Retrieve property images and related information.
7. Map the returned data into WordPress, Laravel, PHP, Node.js or a custom SaaS database.
8. Use incremental synchronization when only changed properties need to be processed.
9. Display synchronized listings through the website or application.

This eliminates the need to manually re-enter every property into a website and creates a reusable property data pipeline for real estate businesses.

---

Get Property Listings From REAP CRM

The primary operation for retrieving property listings is:

properties

A basic GraphQL query can request the property information required by a website:

query GetProperties($filters: PropertyFilterInput) {
  properties(filters: $filters) {
    count
    statusCode
    errorMessage
    data {
      id
      referenceNumber
      slug
      price
      numberOfBedrooms
      numberOfBathrooms
      isSale
      expiresOn
    }
  }
}

The corresponding variables can define pagination and the property type:

{
  "filters": {
    "page": 1,
    "size": 20,
    "type": "sale"
  }
}

The API documentation describes 1-based pagination using page and size. Sorting can also be controlled using sortKey and sortDirection.

---

REAP CRM API for Sale and Rental Properties

A real estate website may need to separate properties for sale from rental listings. The API supports this through the type filter.

Get Properties for Sale

{
  "filters": {
    "page": 1,
    "size": 20,
    "type": "sale"
  }
}

Get Rental Properties

{
  "filters": {
    "page": 1,
    "size": 20,
    "type": "rent"
  }
}

This makes it possible to build separate property for sale and property for rent sections while keeping REAP CRM as the underlying property data source.

---

Search REAP Properties by Price, Bedrooms and Bathrooms

Real estate websites typically require advanced search functionality. The REAP API supports property filters based on several numeric property attributes.

{
  "filters": {
    "page": 1,
    "size": 20,
    "type": "sale",
    "minNumberOfBedrooms": 2,
    "maxPrice": 500000,
    "sortKey": "price",
    "sortDirection": "ASC"
  }
}

Available filters documented for the property operation include:

• Minimum price
• Maximum price
• Minimum bedrooms
• Maximum bedrooms
• Minimum bathrooms
• Maximum bathrooms
• Car spaces
• Internal area
• External area
• Plot area
• Total area

This allows developers to build advanced property search interfaces instead of relying on a static property feed.

---

REAP CRM Property Search by Locality

Location-based search is one of the most important parts of any property portal. REAP provides a dedicated localities operation that can be used to resolve locality identifiers.

query GetLocalities($filters: LocalityFilterInput) {
  localities(filters: $filters) {
    count
    statusCode
    errorMessage
    data {
      id
      title
      code
    }
  }
}

Once the correct locality identifier is known, it can be supplied to the property search:

{
  "filters": {
    "page": 1,
    "size": 20,
    "localityIdentifiers": [
      "LOCALITY_ID_HERE"
    ]
  }
}

This approach can be used to create location filters, locality landing pages and property search experiences around the REAP data.

---

REAP CRM Property Category Integration

The API also provides a categories operation for retrieving property category information.

query GetCategories($filters: CategoryFilterInput) {
  categories(filters: $filters) {
    count
    statusCode
    errorMessage
    data {
      id
      title
      code
      parentIdentifier
      isCommercial
    }
  }
}

Category identifiers can then be supplied to the property query:

{
  "filters": {
    "page": 1,
    "size": 20,
    "categoryIdentifiers": [
      "CATEGORY_ID_HERE"
    ]
  }
}

This can help developers create category-based searches for residential, commercial and other property classifications supported by the connected REAP system.

---

REAP CRM Property Images API

Property images are available through the nested images field in the property response.

images {
  id
  position
  image {
    protocol
    baseURL
    imagePath
    query
  }
}

The API also provides a thumbnail structure:

thumbnail {
  protocol
  baseURL
  imagePath
  query
}

Image information can be used to create:

• Property galleries
• Property thumbnails
• Featured property images
• Property detail sliders
• WordPress media integrations
• Custom SaaS image galleries

The supplied documentation describes the returned image components but does not document a separate image-download endpoint. A production integration should therefore use the documented image information according to the requirements of the target platform.

---

Get a Single REAP Property by Reference Number

A custom property website may need to retrieve an individual listing rather than loading the entire property database. The API supports filtering properties by reference number.

query PropertyByReference($filters: PropertyFilterInput) {
  properties(filters: $filters) {
    count
    data {
      id
      referenceNumber
      slug
      price
      writeUp
      numberOfBedrooms
      numberOfBathrooms
      expiresOn

      images {
        id
        position
        image {
          protocol
          baseURL
          imagePath
          query
        }
      }

      agent {
        id
        name
        surname
        email
        contactNumber
      }

      locality {
        id
        title
      }

      category {
        id
        title
      }
    }
  }
}

{
  "filters": {
    "referenceNumbers": [
      "ABC123"
    ],
    "page": 1,
    "size": 1
  }
}

The API also supports retrieving a property by its slug, which can be useful for search-engine-friendly property URLs and custom property detail pages.

---

REAP Featured Properties API

Real estate websites commonly display selected properties on the homepage. REAP provides a dedicated featuredProperties operation for this purpose.

query FeaturedProperties($filters: PropertyFilterInput) {
  featuredProperties(filters: $filters) {
    count
    statusCode
    errorMessage
    data {
      id
      referenceNumber
      slug
      price
      isSale

      thumbnail {
        protocol
        baseURL
        imagePath
        query
      }

      locality {
        id
        title
      }
    }
  }
}

This can be used for:

• Homepage featured properties
• Featured property carousels
• Premium property sections
• Featured listing widgets
• Custom property landing pages

---

REAP CRM Agent API Integration

Property websites often need to connect listings with their agents. The REAP API provides an agents lookup operation.

query GetAgents($filters: AgentFilterInput) {
  agents(filters: $filters) {
    count
    statusCode
    errorMessage
    data {
      id
      name
      surname
      agentCode
      slug
      email
      contactNumber
    }
  }
}

Agent identifiers can then be used to filter properties and build connected agent/property pages.

---

REAP CRM Incremental Property Synchronization

One of the most important considerations when building a large property synchronization system is avoiding unnecessary processing.

Instead of requesting and processing the entire property database on every synchronization cycle, a custom integration can use the documented modifiedAfter filter to request properties changed after a specific timestamp.

query IncrementalProperties($filters: PropertyFilterInput) {
  properties(filters: $filters) {
    count
    data {
      id
      referenceNumber
      lastUpdated
      expiresOn
      price
      isSale
      slug
    }
  }
}

{
  "filters": {
    "modifiedAfter": "2026-09-01T00:00:00Z",
    "page": 1,
    "size": 100,
    "sortKey": "lastupdated",
    "sortDirection": "ASC"
  }
}

This approach can dramatically reduce unnecessary API processing for a website or SaaS application that already has a local copy of REAP property records.

Important: the supplied documentation states that using modifiedAfter, modifiedBefore, expiresBefore, or expiresAfter disables the normal default non-expired filter. The integration should therefore evaluate expiresOn itself when performing synchronization with these filters.

---

Understanding REAP Property Website Visibility

A common question when building a REAP property synchronization plugin is how to determine whether a property should remain visible on the website.

The documented API does not expose a simple showOnWebsite boolean. Instead, website visibility is represented through:

expiresOn

A future expiry date indicates a published listing, while a past expiry date indicates that the listing is no longer active for normal website visibility.

For normal property queries, the server applies the non-expired rule by default. However, when modification or expiry filters are used, the integration needs to evaluate the returned expiresOn value itself.

---

What Property Data Can Be Retrieved From REAP CRM?

The documented API exposes considerably more than a basic property title and price.

• Property ID
• Reference number
• External CRM identifier
• Property slug
• Price
• Sale/rent status
• Property title
• Property description/write-up
• Bedrooms
• Bathrooms
• Car spaces
• Internal area
• External area
• Plot area
• Total area
• Creation date
• Last updated date
• Expiry date
• Coordinates
• Residential status
• Sole agency status
• New-property flag
• Energy information
• Website URL
• YouTube URL
• Virtual tour URL
• Images
• Tags
• Agent information
• Category
• Locality
• Project information
• Rooms and features
• Attachments
• Price history

This gives developers a strong foundation for creating a complete REAP property website integration rather than a simple listing importer.

---

Building a REAP CRM WordPress Integration Plugin

If the objective is to build a WordPress website around REAP CRM data, the GraphQL API can be connected through a custom WordPress plugin.

REAP CRM
     ↓
Elastic GraphQL API
     ↓
Custom WordPress REAP Plugin
     ↓
Property CPT / Custom Fields
     ↓
WordPress Search
     ↓
Property Detail Pages
     ↓
SEO-Friendly Website

A custom plugin can be designed to synchronize:

• Property details
• Property prices
• Sale/rent status
• Categories
• Localities
• Agents
• Images
• Descriptions
• Property URLs
• Features
• Property metadata

For larger property databases, incremental synchronization using modifiedAfter can reduce unnecessary processing and help the WordPress website stay synchronized with the upstream property data.

---

REAP CRM API Integration for Laravel and Custom PHP

REAP CRM does not have to be connected only to WordPress.

The GraphQL architecture can also be consumed by a custom:

• Laravel application
• PHP property portal
• Node.js application
• React frontend
• Next.js application
• Mobile application backend
• Real estate SaaS platform
• Custom CRM
• Property marketplace
• Internal agency dashboard

This is particularly useful when the business does not want REAP property data displayed directly from a remote API on every page request and instead requires a local normalized property database.

---

REAP CRM to SaaS Property Synchronization Architecture

A larger SaaS platform can use REAP as the upstream source while maintaining its own property database.

                 ┌───────────────────────┐
                 │       REAP CRM        │
                 └───────────┬───────────┘
                             │
                             ▼
                 ┌───────────────────────┐
                 │ Elastic GraphQL API   │
                 └───────────┬───────────┘
                             │
                             ▼
                 ┌───────────────────────┐
                 │ Sync / Normalization  │
                 │       Engine          │
                 └───────────┬───────────┘
                             │
              ┌──────────────┼──────────────┐
              ▼              ▼              ▼
        ┌───────────┐  ┌────────────┐  ┌────────────┐
        │ WordPress │  │ Laravel    │  │ SaaS App   │
        │ Website   │  │ Portal     │  │ / Mobile   │
        └───────────┘  └────────────┘  └────────────┘

This architecture allows the synchronization layer to handle normalization, incremental processing, error handling, local storage and application-specific mapping independently from the frontend.

---

REAP CRM API Integration With Postman

Before developing a WordPress plugin or SaaS integration, developers can test the REAP GraphQL API using Postman.

HTTP Method

POST

API URL

https://elastic-api.isb-software.co.uk/api/graphql

Headers

Content-Type: application/json
X-System-Identifier: YOUR_SYSTEM_IDENTIFIER

The request body contains the GraphQL query and its variables.

Postman can be used to test:

• Property searches
• Sale properties
• Rental properties
• Featured properties
• Properties by reference
• Properties by slug
• Property images
• Localities
• Categories
• Agents
• Incremental synchronization
• Pagination
• Sorting

---

Why Use a Custom REAP CRM Integration Instead of Manual Property Entry?

Manual property entry creates unnecessary duplication between the CRM and website.

Every time an agent changes:

• Price
• Description
• Property status
• Bedrooms
• Bathrooms
• Images
• Location
• Agent information
• Property expiry

the website may also need to be updated.

With an automated REAP CRM property synchronization system, the website can consume the upstream property data programmatically instead of depending on staff to duplicate every change.

---

REAP CRM API Integration for SEO-Friendly Property Websites

A custom integration also provides more control over how property information is presented to search engines.

Instead of embedding a generic external property interface, developers can build native website pages containing:

• Search-engine-friendly property URLs
• Property titles
• Unique descriptions
• Location information
• Property attributes
• Images
• Agent information
• Breadcrumb navigation
• Internal property links
• Structured data

The API therefore becomes the data source, while WordPress or the custom SaaS application controls the presentation, URL structure, SEO implementation and frontend experience.

---

Common REAP CRM Integration Projects

• REAP CRM to WordPress integration
• REAP CRM WordPress plugin development
• REAP property API integration
• REAP GraphQL API integration
• REAP CRM property feed integration
• REAP CRM to Laravel integration
• REAP CRM SaaS synchronization
• REAP property portal development
• REAP CRM property website integration
• REAP property search integration
• REAP CRM listing synchronization
• REAP CRM property image synchronization
• Custom real estate API development
• Real estate CRM to website integration

---

Why Work With a Custom Real Estate API Developer?

A basic API request is only the first step in a production integration.

A reliable implementation also needs to consider:

• API authentication and tenant identification
• GraphQL query design
• Pagination
• Incremental synchronization
• Property ID mapping
• Duplicate prevention
• Property status handling
• Expiry handling
• Image processing
• Database optimization
• Error logging
• Retry mechanisms
• Scheduled synchronization
• WordPress custom post types
• Custom fields and taxonomies
• Frontend property search
• SEO-friendly property URLs

This is where an experienced real estate API developer can turn the documented REAP API into a complete business-ready property synchronization system.

---

Frequently Asked Questions About REAP CRM API Integration

---

Build a Custom REAP CRM API Integration

If you need to connect REAP CRM with WordPress, WooCommerce, Laravel, PHP, React, Next.js, a custom property portal, mobile application or SaaS platform, a custom integration can turn the REAP GraphQL API into a complete automated property data pipeline.

• REAP CRM API integration
• REAP GraphQL integration
• REAP CRM WordPress plugin
• REAP property synchronization
• REAP property website integration
• REAP CRM SaaS integration
• Custom real estate API development
• Property feed and database synchronization
• Property search and filtering
• Property image synchronization

📩 Schedule a meeting on Upwork to discuss your REAP CRM API integration, WordPress plugin, property portal or SaaS synchronization project.

🎯 Schedule a meeting on Fiverr for custom real estate API integration and property synchronization development.

---

Conclusion

REAP CRM API integration provides developers with a practical way to connect REAP-synchronized property data with websites, WordPress plugins, custom applications and SaaS platforms.

The documented Elastic GraphQL API provides property searching, sale and rental filtering, price and bedroom filters, localities, categories, agents, featured properties, images, property references, slugs and incremental synchronization capabilities.

For a simple website, the API can be queried directly. For a larger WordPress website, property portal or SaaS application, a custom synchronization layer can provide local property storage, scheduled updates, incremental processing, custom mapping, SEO-friendly property pages and complete control over the frontend experience.

If your goal is to build a REAP CRM WordPress integration, custom property website, REAP API synchronization plugin, Laravel property portal or real estate SaaS platform, the first step is designing the API-to-application architecture around your specific property data requirements.