.png)
RealPage Integration Guide
Integrate RealPage property-management data with enterprise systems through approved product-specific APIs, partner interfaces, scheduled workflows, and controlled data exchanges.
RealPage integration options at a glance
RealPage provides API and partner integration capabilities, but the available mechanisms vary by product, tenant, and customer agreement. REST API access is partially documented and generally requires RealPage approval, product-specific endpoint details, and provisioned credentials. Authentication may use OAuth 2.0, API keys, client credentials, tenant identifiers, or other partner-issued credentials. General-purpose webhooks, bulk APIs, and file exchanges are not publicly confirmed across the portfolio and must be validated for the relevant module. Martini can consume approved RealPage APIs, schedule incremental synchronization, transform JSON or XML payloads, apply validation and business rules, and expose controlled APIs for downstream consumers.
| Integration point | Supported by RealPage? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Limited | RealPage provides API and partner integration capabilities for selected products, including property management, leasing, payments, maintenance, and related operations. Endpoint coverage, object names, and write permissions vary by product and tenant. | Martini can consume an approved RealPage REST API from workflows, transform responses, apply business rules, and write results to downstream applications or data stores. |
| Authentication | Limited | Authentication is provisioned through RealPage’s partner or integration program and may involve OAuth 2.0, API keys, client credentials, tenant identifiers, or partner-issued credentials. Required scopes and permissions are product-specific. | Martini stores environment-specific credentials in Secrets Management and uses configured authentication when calling approved RealPage endpoints. |
| Webhooks and outbound callbacks | Not confirmed | General-purpose webhook or callback coverage is not publicly confirmed across RealPage products. Event support for changes to Properties, Units, Residents, Applicants, Leases, Work Orders, or Payments must be verified for the target product. | Martini can receive webhook-style events if the relevant RealPage product explicitly supports and authorizes them; otherwise, scheduled polling can provide an alternative. |
| Bulk, asynchronous, or batch APIs | Not confirmed | Batch or scheduled exchange may exist for selected products or partner interfaces, but a general-purpose public RealPage bulk API was not verified. | Martini can orchestrate batch-style workflows when RealPage provides a documented endpoint or exchange contract, including checkpointing and replay handling. |
| File and attachment exchange | Limited | RealPage products commonly handle documents and property-management data, but a portfolio-wide file or attachment API was not verified. SFTP, document endpoints, signed URLs, and file permissions must be confirmed per implementation. | Martini can process confirmed file or attachment exchanges and map document metadata or file contents into downstream workflows without assuming that a document reference contains a retrievable file. |
| Scheduled synchronization | Limited | Scheduled polling is an appropriate integration pattern when outbound events are unavailable or limited. Incremental retrieval depends on vendor-supported timestamps, status filters, cursors, or change markers. | Martini can trigger scheduled workflows, persist synchronization checkpoints, use overlap windows, and perform idempotent upserts to downstream systems. |
| Database access | No | Direct customer database or analytics-database access is not documented as a supported RealPage integration mechanism. | Martini should use approved RealPage APIs, partner interfaces, or confirmed file exchanges rather than connecting directly to RealPage databases. |
How RealPage exposes data and business events
RealPage REST APIs
RealPage provides API and partner integration capabilities, but the public research does not establish one uniform REST API across the entire product portfolio. Access, object coverage, operations, and tenant permissions must be confirmed for the relevant RealPage module.
Martini implementation pattern
Martini implementation pattern: Martini calls the approved RealPage REST endpoints from a workflow, authenticates with environment-configured credentials, retrieves paginated or filtered data, validates the response, maps it to a canonical model, and writes the result to a downstream application or data store.
Implementation sequence
RealPage Webhooks and callbacks
General-purpose RealPage webhooks or outbound callbacks are not publicly confirmed across the product portfolio. Event coverage must be explicitly authorized and validated for the target product and tenant.
Martini implementation pattern
Martini implementation pattern: if RealPage provides an authorized callback for the required event, Martini can receive it through a controlled API or webhook workflow, validate the notification, retrieve the current resource when necessary, and apply idempotent downstream processing. If callbacks are unavailable, a scheduled synchronization workflow should be used instead.
Implementation sequence
Scheduled RealPage synchronization
Scheduled synchronization is a practical fallback when RealPage does not provide suitable event notifications. The workflow can retrieve changed Properties, Units, Residents, Applicants, Leases, or Work Orders when the approved interface supports incremental filters or change markers.
Martini implementation pattern
Martini implementation pattern: a scheduler starts a workflow that reads the last successful checkpoint, requests an incremental RealPage data set, applies an overlap window, transforms and validates each object, writes idempotently to the target, and stores the checkpoint only after successful processing.
Implementation sequence
RealPage file and document exchange
RealPage products may support document or file-related exchanges, but a general-purpose public file API was not verified. File endpoints, SFTP, signed URLs, upload permissions, MIME types, and size limits require product-specific confirmation.
Martini implementation pattern
Martini implementation pattern: when an approved file or document interface exists, Martini receives or retrieves the exchange, validates metadata and content, transforms accompanying data, and routes the result to the target system while keeping document access separate from ordinary transactional API permissions.
Implementation sequence
Common RealPage integration patterns
Pattern 1: Synchronize residents and leases
When to use this pattern
Use this pattern when a CRM, resident-service platform, reporting database, or warehouse needs current RealPage occupancy and leasing information and suitable outbound events are unavailable.
Integration direction
Example Mapping
| RealPage Field | Canonical Field | Target Field |
|---|---|---|
| Resident.id | residentExternalId | resident_source_id |
| Lease.startDate | leaseStartDate | lease_start_date |
| Lease.endDate | leaseEndDate | lease_end_date |
| Unit.propertyId | propertyExternalId | property_source_id |
Martini implementation pattern
A scheduled Martini workflow retrieves changed Residents, Units, Properties, and Leases using approved filters or timestamps. It applies an overlap window, validates relationships and sensitive-field rules, upserts by stable RealPage identifiers, and records failures for replay without advancing the checkpoint prematurely.
Martini capabilities used
- workflows
- scheduling
- API consumption
- data mapping
- business rules
- error handling
Pattern 2: Synchronize maintenance work orders
When to use this pattern
Use this pattern to exchange maintenance requests and service status between RealPage and a field-service or enterprise work-management application such as ServiceNow.
Integration direction
Example Mapping
| RealPage Field | Canonical Field | Target Field |
|---|---|---|
| WorkOrder.id | workOrderExternalId | correlation_id |
| WorkOrder.status | workOrderStatus | state |
| WorkOrder.priority | priority | priority |
| WorkOrder.completedDate | completionTimestamp | closed_at |
Martini implementation pattern
Martini retrieves or receives approved Work Order data, maps RealPage statuses to the target vocabulary, applies ownership rules for assignment and completion fields, and performs idempotent writes. Retry handling and source identifiers prevent duplicate work orders and update loops.
Martini capabilities used
- workflows
- API consumption
- data mapping
- conditional routing
- idempotency
- error handling
Pattern 3: Exchange applicants and leasing activity
When to use this pattern
Use this pattern when leasing operations need Applicants and application status in a CRM or another approved leasing platform, subject to RealPage permissions and privacy requirements.
Integration direction
Example Mapping
| RealPage Field | Canonical Field | Target Field |
|---|---|---|
| Applicant.id | applicantExternalId | realpage_applicant_id |
| Applicant.status | applicationStatus | application_status |
| Applicant.createdDate | applicationCreatedAt | created_date |
| Property.id | propertyExternalId | property_source_id |
Martini implementation pattern
A Martini workflow retrieves approved Applicant data, minimizes sensitive fields, maps status values, validates required property relationships, and upserts Salesforce data using the RealPage identifier. Authorization failures and malformed application states are routed to an operational review path.
Martini capabilities used
- API consumption
- data mapping
- validation
- business rules
- secure configuration
- error handling
Pattern 4: Distribute property and unit master data
When to use this pattern
Use this pattern when downstream reporting, finance, resident-service, or analytics applications require a consistent view of RealPage Properties, Units, availability, and related master data.
Integration direction
Example Mapping
| RealPage Field | Canonical Field | Target Field |
|---|---|---|
| Property.id | propertyExternalId | property_source_id |
| Property.name | propertyName | property_name |
| Unit.id | unitExternalId | unit_source_id |
| Unit.status | unitStatus | unit_status |
Martini implementation pattern
Martini periodically retrieves approved master data, preserves source identifiers and relationships, normalizes status and address values, and loads a governed data store. Power BI can consume the resulting reporting model without directly coupling dashboard activity to RealPage API calls.
Martini capabilities used
- scheduling
- API consumption
- data mapping
- transformation
- validation
- monitoring
Applications commonly integrated with RealPage
RealPage data can be connected to adjacent enterprise applications when the required RealPage product interfaces and write permissions are available. The following are common architecture targets rather than universally certified RealPage integrations; each implementation should validate product, tenant, object, and authorization coverage.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize leasing prospects, Applicants, Residents, Properties, and leasing activity with sales and resident-engagement teams. | RealPage → Martini → Salesforce | A scheduled Martini workflow retrieves approved RealPage data, maps source identifiers and leasing fields to Salesforce objects, applies duplicate checks, and performs idempotent upserts. Selected updates can be returned only where RealPage provides an authorized write operation. |
| ServiceNow | Exchange Work Orders, maintenance requests, assignments, and completion statuses with enterprise service-management processes. | RealPage → Martini → ServiceNow | Martini orchestrates Work Order extraction and ServiceNow writes, maps status and assignment values, and applies ownership rules to prevent bidirectional update loops. Failed writes are logged for retry or replay. |
| NetSuite | Transfer property, resident, lease, charge, payment, or vendor-related data into financial and operational processes. | RealPage → Martini → NetSuite | A Martini workflow extracts approved RealPage objects, normalizes dates, currencies, and external identifiers, and sends validated payloads to NetSuite. Financial write-back is enabled only after the relevant RealPage and NetSuite operations are confirmed. |
| Workday | Coordinate employee, vendor, or finance-related information where property operations connect with corporate HR and finance processes. | Workday → Martini → RealPage | Martini can coordinate approved Workday and RealPage interfaces through a reusable workflow, applying domain-specific routing so employee or vendor data is sent only to the product operations that require it. |
| Microsoft Dynamics 365 | Synchronize customer, prospect, property, and operational data with CRM or ERP processes. | RealPage → Martini → Microsoft Dynamics 365 | Martini retrieves supported RealPage objects, maps them to Dynamics 365 schemas, applies external-key matching, and routes validation failures separately from successful upserts. Bidirectional synchronization requires explicit ownership rules. |
| Snowflake | Load property, unit, lease, resident, work-order, and financial data for analytics and reporting. | RealPage → Martini → Snowflake | A scheduled Martini workflow retrieves incremental RealPage data, preserves source identifiers, transforms payloads into warehouse-ready structures, and loads Snowflake through an approved ingestion interface or intermediate file exchange. |
| Microsoft Power BI | Provide reporting datasets for occupancy, leasing, maintenance, revenue, and resident operations. | RealPage → Martini → Snowflake → Microsoft Power BI | Martini prepares and loads RealPage data into a reporting store such as Snowflake, where Power BI consumes governed datasets. This avoids coupling transactional RealPage calls directly to dashboard refresh activity. |
| DocuSign | Coordinate lease or resident-document workflows where document signing is part of the approved leasing process. | RealPage → Martini → DocuSign | Martini can coordinate document metadata, signing requests, and status updates when RealPage exposes the required document interfaces. File retrieval, upload permissions, and document identifiers must be validated separately from transactional API access. |
How to build a RealPage integration in Martini
Objective
Establish the RealPage product, tenant, environment, endpoint, and permission scope before implementing workflow logic.
Instructions in Martini
- Confirm the RealPage module and approved integration contract
- Validate the API or file interface and read/write permissions
- Store credentials, tenant identifiers, and environment values in Martini Secrets Management
- Separate development, test, and production configuration
Objective
Select an event-driven or scheduled entry point based on the integration mechanisms RealPage has actually provisioned.
Instructions in Martini
- Use a RealPage callback only when event coverage is explicitly confirmed
- Use a Scheduler Trigger for polling and incremental synchronization
- Define the polling interval, overlap window, and checkpoint strategy
- Avoid assuming that all RealPage object changes generate events
Objective
Call the approved RealPage interface and handle vendor-specific pagination, filters, response formats, and object availability.
Instructions in Martini
- Request only the Properties, Units, Applicants, Residents, Leases, or Work Orders in scope
- Implement documented pagination or cursor behavior
- Persist the last successful timestamp or source cursor
- Treat product-specific fields and identifiers as part of the integration contract
Objective
Coordinate extraction, validation, transformation, target writes, checkpointing, and operational outcomes in a maintainable Martini workflow.
Instructions in Martini
- Separate retrieval, transformation, business rules, and target delivery stages
- Use reusable workflow logic for common authentication, pagination, and error handling
- Route permanent validation failures separately from transient transport failures
- Do not advance a synchronization checkpoint until the relevant work completes successfully
Objective
Convert RealPage payloads into canonical and target-specific schemas while preserving traceability and protecting sensitive data.
Instructions in Martini
- Map stable RealPage identifiers to external keys
- Normalize dates, time zones, monetary values, addresses, and status codes
- Minimize applicant, resident, lease, payment, and screening data
- Handle JSON or XML structures according to the confirmed interface contract
Objective
Enforce data quality, ownership, privacy, and duplicate-prevention rules before writing to downstream systems.
Instructions in Martini
- Validate required property, unit, resident, lease, and work-order relationships
- Use idempotent upserts or duplicate detection for retries
- Define ownership for bidirectional status and assignment updates
- Reject unexpected enumerations or schema changes rather than silently dropping data
Common RealPage data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Properties | Communities, buildings, or managed real estate assets used as the organizational anchor for operational data. | Snowflake, Microsoft Power BI, Salesforce, Microsoft Dynamics 365 | Martini retrieves approved property data, preserves the RealPage identifier, normalizes addresses and property classifications, and distributes validated master data. |
| Units | Individual apartments or rentable units associated with a Property, including availability and related lease context. | Snowflake, Salesforce, Microsoft Dynamics 365, resident portals | Martini maps unit and property relationships, applies incremental synchronization rules, and prevents duplicate units through stable source identifiers. |
| Applicants | Prospective residents involved in rental applications, leasing, and screening processes. | Salesforce, Microsoft Dynamics 365, approved leasing platforms | Martini minimizes sensitive fields, validates application status values, maps applicants to target schemas, and routes authorization or validation failures for review. |
| Residents | Current or former occupants associated with a Property and Unit. | Salesforce, Snowflake, resident-service platforms, NetSuite | Martini applies privacy-aware field selection, preserves source IDs, normalizes contact and occupancy data, and performs idempotent target updates. |
| Leases | Rental agreements containing lease terms, dates, rent, and occupant relationships. | NetSuite, Snowflake, Salesforce, reporting platforms | Martini maps lease dates, monetary values, status fields, and related identifiers while accounting for property-local time zones and date-only values. |
| Work Orders | Maintenance requests and associated assignment, service, priority, and completion activity. | ServiceNow, Snowflake, field-service platforms, Microsoft Power BI | Martini synchronizes approved work-order fields, applies status ownership rules, detects duplicates after retries, and handles bidirectional updates without echo loops. |
Authentication and security considerations
Product-specific authentication
RealPage access is commonly provisioned through a partner or integration program. OAuth 2.0, API keys, client credentials, tenant identifiers, and partner-issued credentials may be used depending on the product and customer agreement.
Secrets and least privilege
Store RealPage credentials and environment configuration in Martini Secrets Management rather than embedding them in workflows or mappings. Confirm scopes and permissions for each product, property, operation, and data object.
Sensitive property data
- Minimize applicant, resident, lease, payment, and screening fields.
- Use encryption in transit and at rest and separate test data from production data.
- Apply access controls, audit logging, retention rules, and credential rotation.
Operational considerations for RealPage integrations
Rate limits and throughput
RealPage rate limits were not publicly verified. Respect documented quotas, use bounded concurrency, avoid retrieving unchanged data, and apply exponential backoff to transient failures.
Pagination and checkpoints
Use the pagination and incremental-filter behavior documented for the specific RealPage interface. Persist the last successful timestamp or cursor, use an overlap window, and support replay without creating duplicates.
Contracts and schema changes
RealPage products may evolve independently. Validate optional fields, status enumerations, identifiers, dates, currencies, and null values. Route unexpected payloads to review rather than silently discarding fields.
Documents and time zones
Do not assume a document reference makes the file available through the same API. Confirm document permissions and endpoints separately. Normalize property-local time zones, lease dates, work-order timestamps, and date-only values.
Why use Martini instead of scripts or point-to-point integrations?
Orchestrate beyond a single API call
Martini coordinates scheduled retrieval, pagination, validation, transformation, business rules, target writes, checkpoints, and replay handling in a maintainable workflow.
Separate systems without hard-coded point-to-point logic
Reusable workflows and mappings can connect RealPage to CRMs, service platforms, financial applications, warehouses, and reporting layers while preserving source identifiers and ownership rules.
Expose controlled enterprise APIs
Martini can expose a REST API that retrieves or transforms approved RealPage data, applies authorization and business rules, and provides a stable interface to internal consumers.
Improve operational control
- Keep credentials and environment values outside workflow logic.
- Handle retries, validation failures, duplicate detection, and replay consistently.
- Monitor workflow outcomes and adapt to product-specific RealPage contracts without rewriting every consuming application.
Frequently asked questions
RealPage can be integrated through approved product-specific APIs and partner interfaces. REST API availability, authentication, object coverage, write permissions, file exchanges, and event support vary by RealPage product and tenant. Where outbound events are unavailable, scheduled workflows can retrieve incremental Properties, Units, Applicants, Residents, Leases, or Work Orders and deliver them to enterprise applications.
Yes. Martini can integrate with RealPage when the customer has access to an approved RealPage API, partner interface, file exchange, or authorized event mechanism. Martini can consume REST APIs, store credentials securely, orchestrate scheduled synchronization, transform payloads, apply business rules, and write to downstream applications.
No. A dedicated RealPage connector is not required. Martini can use RealPage’s confirmed native integration mechanisms, such as approved REST APIs, product-specific partner interfaces, authorized callbacks, or confirmed file exchanges. No native Martini RealPage connector is documented in the supplied product information.
Lonti does not charge an additional per-connector or per-vendor fee to integrate RealPage. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from RealPage, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.
Use the approved interface for the specific RealPage product and tenant. REST APIs are the primary confirmed direction, but endpoint coverage and authentication are product-specific. Scheduled synchronization is appropriate when event notifications are unavailable. File, batch, callback, and document mechanisms should be used only when explicitly documented and provisioned by RealPage.
General-purpose webhooks and outbound callbacks are not confirmed across the RealPage portfolio. Event coverage for Properties, Units, Applicants, Residents, Leases, Work Orders, or Payments must be verified with RealPage for the relevant product. If callbacks are unavailable, Martini can use scheduled polling and incremental checkpoints.
Martini workflows can retrieve incremental data using vendor-supported timestamps, filters, cursors, or change markers; handle pagination; map RealPage objects to canonical and target schemas; and perform idempotent upserts. Stable RealPage identifiers, overlap windows, validation, and checkpointing help prevent missed updates and duplicates.
Martini can classify authentication failures, rate limits, timeouts, validation errors, and endpoint failures; retry transient conditions with safe backoff; and route permanent failures for review or replay. Stable source identifiers and idempotent writes reduce duplicates, while ownership rules prevent bidirectional Work Order or status synchronization loops.
Related Martini documentation
Workflows
Operations
Connect RealPage with your enterprise systems
Use Martini to implement maintainable RealPage integrations with approved APIs, scheduled workflows, secure configuration, data mapping, validation, and operational error handling.