.png)
AppFolio Integration Guide
Connect AppFolio property-management data to enterprise applications through approved REST APIs, OAuth 2.0 authorization, and selected event notifications.
AppFolio integration options at a glance
AppFolio’s partner-facing integration model is centered on approved REST API access to property-management data, authorized through OAuth 2.0. Selected integration scenarios may also provide webhook or event notifications, but coverage depends on the AppFolio Stack product, enabled resources, and customer authorization. Martini can consume AppFolio JSON responses, process paginated collections, apply mappings and business rules, and expose controlled APIs for downstream systems. Scheduled workflows support incremental synchronization where documented timestamps, filters, or watermarks are available. A general-purpose bulk API, GraphQL API, SOAP API, file API, or direct database connection was not confirmed.
| Integration point | Supported by AppFolio? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Retrieve and, where authorized, create or update supported AppFolio resources such as Properties, Units, Tenants, Leases, Owners, and Vendors. | Martini consumes AppFolio REST endpoints from workflows, handles JSON responses, maps fields, and can expose controlled APIs for downstream consumers. |
| Webhooks and outbound callbacks | Limited | Receive selected AppFolio event notifications for approved integration scenarios. Coverage, payloads, and enrollment are resource- and event-specific. | Martini can expose an API endpoint or webhook-consuming workflow, validate notifications, deduplicate deliveries, and retrieve the authoritative AppFolio resource. |
| Authentication | Yes | Authorize approved partner or customer integrations using OAuth 2.0, with permissions determined by the AppFolio product and customer configuration. | Martini stores OAuth configuration and tokens in secrets or protected environment configuration and uses them in API workflows. |
| Scheduled synchronization | Yes | Run recurring property, tenant, lease, accounting, or operational synchronizations when event coverage is unavailable or incomplete. | Martini scheduler-triggered workflows page through resources, apply rate-aware processing, and persist cursors or watermarks where supported. |
| Incremental synchronization | Limited | Use documented update timestamps, change filters, or event notifications when available for a specific AppFolio resource. | Martini maintains durable synchronization state, maps source identifiers, and performs idempotent upserts while avoiding assumptions about universal incremental support. |
| Pagination and filtering | Yes | Process collection endpoints containing Properties, Units, Tenants, Leases, or other authorized resources without assuming a complete single response. | Martini workflows iterate through pages, retain checkpoints, and apply documented filters to support resumable synchronization. |
| Bulk or asynchronous APIs | Not confirmed | No general-purpose AppFolio bulk or asynchronous API was confirmed. Large transfers should use documented pagination and scheduled processing unless a resource-specific capability is approved. | Martini can orchestrate paginated and scheduled processing, but does not imply an AppFolio bulk mechanism where one is not documented. |
| File and attachment APIs | Not confirmed | A general AppFolio file or attachment API was not confirmed. Document, invoice, or file handling must be verified for the selected resource. | Martini can process files when an approved AppFolio endpoint exposes them, but the implementation must be based on the documented resource capability. |
| GraphQL and SOAP APIs | No | No official AppFolio GraphQL or SOAP API was confirmed in the research. | Martini should use the confirmed AppFolio REST API model rather than assuming GraphQL or SOAP access. |
How AppFolio exposes data and business events
AppFolio REST APIs
AppFolio’s approved partner integration model is centered on REST APIs that expose authorized property-management resources. Available resources and write operations depend on the customer’s AppFolio product, permissions, and integration approval.
Martini implementation pattern
Martini invokes AppFolio REST endpoints from workflows, supplies OAuth 2.0 authorization, processes JSON responses page by page, and maps resources into downstream models. The workflow can apply business rules, persist checkpoints, and expose a controlled Martini API when another system needs a stable interface.
Implementation sequence
AppFolio Webhooks and Event Notifications
AppFolio provides webhook or event-notification capabilities for selected integration scenarios. Event types, payloads, enrollment requirements, and object coverage must be verified for the specific AppFolio Stack integration.
Martini implementation pattern
Martini exposes an API endpoint or webhook-consuming workflow for the supported notification, validates the request, records an event identifier when available, and retrieves the current AppFolio resource. Processing can continue asynchronously so the endpoint responds quickly and duplicate deliveries can be safely ignored.
Implementation sequence
AppFolio Scheduled Synchronization
Scheduled synchronization is appropriate when webhook coverage is unavailable, incomplete, or not enabled for a required AppFolio resource. The workflow should use documented pagination, filters, and change fields rather than assuming universal incremental access.
Martini implementation pattern
Martini scheduler-triggered workflows retrieve authorized collections, limit concurrency, apply an AppFolio-supported timestamp or change filter where available, and persist a durable cursor or watermark. Results are transformed and written using idempotent keys, with reconciliation for missed or failed items.
Implementation sequence
Common AppFolio integration patterns
Pattern 1: Synchronize properties and leases
When to use this pattern
Use this pattern to maintain a downstream warehouse, resident application, CRM, or property platform with current AppFolio Properties, Units, Tenants, and Leases. It is suitable for scheduled processing or resource-specific incremental synchronization.
Integration direction
Example Mapping
| AppFolio Field | Canonical Field | Target Field |
|---|---|---|
| propertyId | property.externalId | property_id |
| unitId | unit.externalId | unit_id |
| tenantId | resident.externalId | resident_id |
| leaseStatus | lease.status | lease_status |
Martini implementation pattern
Martini authenticates with OAuth 2.0, retrieves changed resources in pages where AppFolio filters or timestamps are available, normalizes identifiers and dates, and upserts related objects in dependency order. A synchronization table stores source keys and checkpoints, while validation and retry paths handle incomplete pages or temporary failures.
Martini capabilities used
- workflows
- API consumption
- scheduler triggers
- data mapping
- business rules
- error handling
Pattern 2: Route maintenance work orders
When to use this pattern
Use this pattern when supported AppFolio maintenance or work-order resources must be sent to a field-service, procurement, or vendor-management application. The exact resource and write permissions must be confirmed for the AppFolio account.
Integration direction
Example Mapping
| AppFolio Field | Canonical Field | Target Field |
|---|---|---|
| propertyId | location.externalId | site_id |
| unitId | asset.externalId | unit_id |
| vendorId | serviceProvider.externalId | vendor_id |
| priority | workItem.priority | priority |
Martini implementation pattern
A Martini workflow polls or receives a supported notification, retrieves the authoritative work-order resource, maps property, unit, tenant, vendor, priority, and status fields, and applies regional routing or escalation rules. It creates or updates the target item using a source identifier and routes rejected or throttled requests to retry handling.
Martini capabilities used
- workflows
- API consumption
- event-driven triggers
- data mapping
- business rules
- retry handling
Pattern 3: Publish event-driven resident updates
When to use this pattern
Use this pattern for selected AppFolio events that need to notify resident portals, support applications, or other operational systems quickly without treating the notification payload as the complete source of truth.
Integration direction
Example Mapping
| AppFolio Field | Canonical Field | Target Field |
|---|---|---|
| eventType | event.type | event_type |
| tenantId | resident.externalId | customer_id |
| propertyId | property.externalId | property_id |
| updatedAt | event.occurredAt | updated_at |
Martini implementation pattern
Martini receives the selected AppFolio notification through an exposed API, validates and deduplicates it, retrieves the current resource, and publishes a normalized event or updates the target application. Asynchronous execution, correlation identifiers, and replayable error handling protect the endpoint from slow downstream systems.
Martini capabilities used
- API exposure
- webhook consumption
- workflows
- data mapping
- asynchronous execution
- error handling
Pattern 4: Exchange accounting and payment data
When to use this pattern
Use this pattern when approved AppFolio accounting, bill, or payment resources must feed NetSuite, QuickBooks Online, a warehouse, or a reporting process. It is especially useful for scheduled reconciliation and financial controls.
Integration direction
Example Mapping
| AppFolio Field | Canonical Field | Target Field |
|---|---|---|
| vendorId | payee.externalId | vendor_id |
| amount | transaction.amount | amount |
| paymentStatus | transaction.status | status |
| transactionId | transaction.externalId | source_transaction_id |
Martini implementation pattern
Martini retrieves supported financial resources page by page, transforms amounts, dates, statuses, and references, and applies duplicate protection before writing to the target. Control counts and amount totals are recorded, while reversals, voids, rate limits, and transient errors receive explicit handling.
Martini capabilities used
- scheduled workflows
- API consumption
- data mapping
- validation
- reconciliation
- retry and error handling
Applications commonly integrated with AppFolio
AppFolio data can be connected to adjacent property, financial, relationship-management, support, and document-signing applications when the required AppFolio resources and target-system APIs are available. These are architecture patterns rather than guaranteed AppFolio-native pairings; resource permissions and write operations should be confirmed for each implementation.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize property, ownership, tenant, or prospect information with relationship-management processes. | AppFolio → Martini → Salesforce | Martini retrieves authorized AppFolio resources on a schedule or from selected event notifications, normalizes identifiers and dates, applies field-level business rules, and performs idempotent Salesforce upserts. Failures are routed for retry and reconciliation. |
| NetSuite | Transfer approved accounting, bill, vendor, or payment data into financial reporting and ERP processes. | AppFolio → Martini → NetSuite | A Martini workflow pages through supported AppFolio accounting resources, validates control totals, maps them to NetSuite records, and records source identifiers to prevent duplicate writes. Temporary API failures use backoff and retry. |
| QuickBooks Online | Exchange property-management accounting or payment information with small and mid-sized business accounting workflows. | AppFolio → Martini → QuickBooks Online | Martini retrieves authorized AppFolio financial data, transforms dates, amounts, statuses, and external references, and sends approved objects to QuickBooks Online through its API. Reversals and voids are handled as explicit state changes. |
| Yardi Voyager | Support portfolio migration, coexistence, or selected exchange of property, resident, lease, and accounting data between property-management environments. | AppFolio → Martini → Yardi Voyager | Martini orchestrates staged extracts and writes between the two platforms, using canonical property, unit, tenant, and lease identifiers. Validation, reconciliation counts, and restartable checkpoints protect large migrations. |
| RealPage | Exchange property, resident, leasing, or operational data where an organization uses both platforms. | AppFolio → Martini → RealPage | Martini consumes the available APIs from each platform, maps differing property and resident models, applies routing rules, and records correlation identifiers for repeatable synchronization. Each platform’s permissions and supported objects are verified separately. |
| Buildium | Support portfolio migration, coexistence, or selected operational data exchange. | AppFolio → Martini → Buildium | A Martini workflow stages AppFolio data, transforms it into the target model, validates required fields, and writes only supported Buildium resources. Exceptions are quarantined with enough source context for correction and replay. |
| DocuSign | Coordinate lease or other document-signing workflows when signed-document processes span AppFolio and DocuSign. | AppFolio → Martini → DocuSign | Where the selected AppFolio integration exposes the required document data, Martini creates or updates DocuSign envelopes, tracks signing status, and returns normalized status information where permitted. File and document capabilities must be confirmed for the AppFolio account. |
| Zendesk | Provide resident, tenant, owner, or property context to support operations. | AppFolio → Martini → Zendesk | Martini retrieves authorized AppFolio context, maps it to Zendesk users, organizations, or tickets, and applies privacy-aware filtering before writing. Event-driven updates can be combined with scheduled reconciliation. |
How to build a AppFolio integration in Martini
Objective
Establish approved AppFolio access and protect OAuth configuration before building resource workflows.
Instructions in Martini
- Confirm AppFolio partner enrollment, customer authorization, environment, scopes, and resource permissions
- Create protected Martini environment configuration for OAuth credentials and tokens
- Test access against only the authorized AppFolio resources
Objective
Select the trigger that matches the resource’s AppFolio capabilities and synchronization urgency.
Instructions in Martini
- Use a supported AppFolio event notification when available
- Use a scheduler for resources without suitable event coverage
- Define the polling interval, concurrency, and backfill strategy
Objective
Fetch the authoritative AppFolio resource or collection while respecting pagination and filtering behavior.
Instructions in Martini
- Call the documented AppFolio REST endpoint
- Process collection responses page by page
- Use documented update filters or a durable watermark where available
- Persist enough state to resume interrupted synchronization
Objective
Coordinate retrieval, enrichment, validation, target writes, and state management in a maintainable Martini workflow.
Instructions in Martini
- Separate event intake from longer-running downstream processing when appropriate
- Add correlation identifiers and explicit branches for validation and retry
- Keep resource mappings isolated from orchestration logic where practical
Objective
Convert AppFolio JSON resources into canonical and target-specific models without losing source identity.
Instructions in Martini
- Map Properties, Units, Tenants, Leases, Owners, or Vendors to the target model
- Normalize identifiers, timestamps, statuses, and amounts
- Apply null, enum, and required-field validation
Objective
Enforce operational, privacy, routing, and reconciliation rules before writing downstream data.
Instructions in Martini
- Apply regional routing, escalation, authorization, and sensitive-data filtering rules
- Use stable AppFolio identifiers for idempotent upserts
- Record control counts and source-to-target correlation data
Common AppFolio data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Properties | Represent managed properties or communities and provide the parent context for units, leases, tenants, owners, and operations. | Salesforce, Yardi Voyager, RealPage, data warehouses | Martini retrieves authorized properties, normalizes identifiers and addresses, maps ownership and operational fields, and performs idempotent upserts. |
| Units | Represent rentable or managed units associated with properties. | Yardi Voyager, Buildium, RealPage, resident portals | Martini links Units to canonical Properties, validates unit status and identifiers, and synchronizes changes using documented filters or scheduled checkpoints. |
| Tenants | Represent tenant or resident profiles used in leasing, service, and resident operations. | Salesforce, Zendesk, Buildium, resident applications | Martini applies privacy-aware mappings, normalizes contact fields, filters sensitive values, and uses stable AppFolio identifiers for deduplication. |
| Leases | Represent lease agreements connecting tenants, units, and properties. | Yardi Voyager, RealPage, DocuSign, reporting platforms | Martini validates relationships between Tenants, Units, and Properties, maps dates and statuses, and reconciles lifecycle changes. |
| Owners | Represent property owners or ownership entities associated with managed properties. | Salesforce, NetSuite, reporting platforms | Martini maps ownership relationships, applies authorization and privacy rules, and synchronizes approved owner data using external identifiers. |
| Vendors | Represent service providers used for maintenance, invoices, or other property operations. | NetSuite, QuickBooks Online, procurement and field-service applications | Martini normalizes vendor identifiers and payment-related attributes, applies routing rules, and handles duplicate detection before downstream writes. |
Authentication and security considerations
OAuth 2.0 authorization
AppFolio integrations use an OAuth-based authorization model for approved API clients and partners. Access depends on customer authorization, partner enrollment, scopes, roles, and resource permissions.
Protecting credentials and data
- Store OAuth client credentials, tokens, and endpoint configuration in Martini secrets or protected environment configuration.
- Use least-privilege AppFolio permissions for the required properties, companies, and resources.
- Protect tenant, owner, lease, payment, and property information from unnecessary logging and retention.
- Separate development, sandbox, and production configuration when those environments are available.
Operational considerations for AppFolio integrations
Rate limits and pagination
Design AppFolio workflows for throttling, HTTP 429 responses, controlled concurrency, and page-by-page collection processing. Separate high-volume backfills from normal incremental synchronization.
Idempotency and webhooks
Use stable AppFolio identifiers, synchronization tables, lookup-before-create logic, or endpoint-supported idempotency strategies. Treat webhook notifications as triggers, record event identifiers when available, and retrieve the current resource rather than assuming the payload is complete.
Schema and reconciliation
Validate required fields, enum values, nullability, date and timezone formats, pagination behavior, and write requirements as APIs evolve. For lease and financial data, compare source and destination counts, amounts, statuses, failures, and last successful synchronization time.
Testing and monitoring
Test with the customer’s authorized resources and representative lifecycle changes. Monitor authentication failures, throttling, schema changes, retries, skipped objects, and sensitive-data exposure in logs.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration beyond scripts
Martini separates AppFolio API consumption, event intake, mapping, business rules, target writes, and synchronization state into maintainable workflows. This supports scheduled, event-driven, and API-led integration patterns without coupling every system directly to AppFolio.
Reusable integration assets
Teams can expose controlled Martini APIs, reuse transformation and validation logic, and create consistent handling for pagination, retries, deduplication, reconciliation, and secure configuration.
Operational reliability
- Centralize OAuth configuration and secrets management.
- Apply consistent retry, error-routing, and monitoring behavior.
- Preserve checkpoints and correlation identifiers for restartable processing.
- Adapt mappings as AppFolio resources and target schemas change.
Frequently asked questions
AppFolio is integrated through approved REST APIs authorized with OAuth 2.0. Selected integration scenarios may also provide webhook or event notifications. Enterprise workflows can retrieve and synchronize authorized Properties, Units, Tenants, Leases, Owners, Vendors, and other resource-specific data using pagination, filtering, transformation, and reconciliation.
Yes. Martini can consume AppFolio’s approved REST APIs, process JSON responses, use OAuth 2.0 credentials stored in protected configuration, and receive supported AppFolio webhook or event notifications through an exposed API or workflow. Available resources and operations depend on AppFolio authorization and the customer’s integration configuration.
No dedicated AppFolio connector is required. Martini can integrate using AppFolio’s confirmed native mechanisms, principally approved REST APIs and OAuth 2.0, with selected webhook or event-notification support where enabled for the specific integration.
Lonti does not charge an additional per-connector or per-vendor fee to integrate AppFolio. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from AppFolio, cloud infrastructure, or other third-party systems based on subscription, usage, and deployment model.
Use AppFolio’s approved REST APIs as the primary method and OAuth 2.0 for authorization. Use selected webhook or event notifications when the required scenario is supported, and use scheduled, paginated synchronization when event coverage is unavailable or incomplete. No official AppFolio GraphQL or SOAP API was confirmed.
AppFolio provides webhook or event-notification capabilities for selected integration scenarios. Coverage is not universal, and event types, payloads, enrollment, and permissions must be confirmed for the specific AppFolio Stack integration. Martini can receive the notification and retrieve the authoritative resource before processing it.
Martini retrieves authorized AppFolio resources in pages, uses documented timestamps or filters where available, and maintains durable synchronization state. Workflows map AppFolio JSON into canonical and target-specific models, apply validation and business rules, and perform idempotent upserts using stable AppFolio identifiers.
Martini workflows can limit concurrency, retry transient failures with backoff, and route persistent errors for review. Webhook processing can record event identifiers and retrieve current resources so duplicate deliveries do not create duplicate writes. Pagination checkpoints, correlation identifiers, and reconciliation totals support restartable processing.
Related Martini documentation
Connect AppFolio with Martini
Use Martini to build secure, maintainable AppFolio integrations around approved REST APIs, OAuth 2.0, selected event notifications, and scheduled synchronization workflows.