Yardi

Before touching Bubble, contact your Yardi system administrator. This step is mandatory — there is no way to begin the integration without administrator involvement. You need three things from your administrator: 1. **API access enabled** on your Yardi account. Yardi Voyager API access is controlled at the system level; your admin must turn it on for your subscription and create a dedicated service account. For Yardi Breeze, they need to generate an API key from the Breeze admin settings. 2. **Your endpoint URL.** There is no single public Yardi API URL. Cloud-hosted Yardi Voyager instances typically use a URL in the format https://[yourorg].yardiasp.com, but this varies. On-premises deployments use an internal network URL. Your administrator must provide this. 3. **Service account credentials.** For Voyager: username, password, serverName, databaseName, and interfaceEntity name (the specific Yardi interface your integration will use, e.g., 'ILSGuestCard' for leads or 'Maintenance' for work orders). For Breeze: an API key. Once your administrator provides these details, make a note of every value and keep them secure. Do not paste them into emails or documents — store them in a password manager and paste them directly into Bubble's API Connector as Private fields. Build time depends heavily on your administrator's availability. Schedule this coordination early — before any Bubble development work begins — to avoid blocking the project.

If your organization uses Yardi Voyager, the API is SOAP-based. Every request is an HTTP POST with an XML body formatted as a SOAP envelope. Here is how to configure this in Bubble's API Connector. Go to your Bubble editor → click **Plugins** in the left sidebar → click **Add plugins** → search for 'API Connector' (by Bubble) → click **Install**. Inside the API Connector, click **Add another API** and name it 'Yardi Voyager'. Set the base URL to your organization's Yardi endpoint (e.g., https://yourorg.yardiasp.com/voyager/webservice/wservice.asmx). For SOAP calls, do not add a shared Authorization header. Instead, Yardi Voyager credentials go inside the SOAP XML body as fields in the authentication element. Click **Add shared parameter**, set the type to **Header**, name it **Content-Type**, value **text/xml;charset=UTF-8**. Check **Private** for any sensitive value. Click **New call**. Set method to **POST**. For the body type, select **Text** (not JSON). In the body field, enter your SOAP envelope template. Use Bubble's dynamic variable syntax `<dynamic_value>` for any value that will change per request. Here is a skeleton template: ```xml <?xml version="1.0" encoding="utf-8"?> <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"> <soap:Body> <GetUnitList xmlns="http://tempuri.org/"> <UserName><dynamic_value>username</dynamic_value></UserName> <Password><dynamic_value>password</dynamic_value></Password> <ServerName><dynamic_value>serverName</dynamic_value></ServerName> <Database><dynamic_value>databaseName</dynamic_value></Database> <InterfaceEntity><dynamic_value>interfaceEntity</dynamic_value></InterfaceEntity> <PropertyCode><dynamic_value>propertyCode</dynamic_value></PropertyCode> </GetUnitList> </soap:Body> </soap:Envelope> ``` For each dynamic variable marked `<dynamic_value>`, mark the credential ones (UserName, Password, ServerName, Database, InterfaceEntity) as **Private** by clicking the eye-slash icon next to that field in the API Connector parameter list. Add a **SOAPAction** header (required by Voyager SOAP services) with the value matching the operation you are calling — your administrator or Yardi's WSDL document specifies the correct SOAPAction string for each operation.

1{
2  "method": "POST",
3  "url": "https://yourorg.yardiasp.com/voyager/webservice/wservice.asmx",
4  "headers": {
5    "Content-Type": "text/xml;charset=UTF-8",
6    "SOAPAction": "http://tempuri.org/GetUnitList"
7  },
8  "body_type": "Text",
9  "body": "<?xml version='1.0' encoding='utf-8'?><soap:Envelope xmlns:soap='http://schemas.xmlsoap.org/soap/envelope/'><soap:Body><GetUnitList xmlns='http://tempuri.org/'><UserName><username_private></UserName><Password><password_private></Password><ServerName><serverName_private></ServerName><Database><databaseName_private></Database><InterfaceEntity><interfaceEntity_private></InterfaceEntity><PropertyCode><dynamic_propertyCode></PropertyCode></GetUnitList></soap:Body></soap:Envelope>"
10}

If your organization uses Yardi Breeze, the API is a standard REST JSON interface — far simpler than Voyager's SOAP setup. In the API Connector, click **Add another API** and name it 'Yardi Breeze'. Set the base URL to the Breeze API endpoint provided by your administrator (e.g., https://api.yardiyardibreeze.com/v1 — confirm the exact URL with your admin). Click **Add shared headers or parameters**. Add a header: - **Name**: Authorization - **Value**: Bearer [your Breeze API key] - **Private**: checked (click the lock/eye icon) Also add: - **Name**: Content-Type - **Value**: application/json - **Private**: unchecked (not a secret) Click **New call**. Give it a descriptive name like 'Get Units'. Set method to **GET**. Set the endpoint path to the units endpoint your administrator specifies (e.g., /units). Add any required query parameters — typically a property ID to scope the results to a specific property in your portfolio. Click **Initialize call** to test the connection. Yardi's Breeze API must return a real, successful response during initialization — Bubble uses this response to detect the data structure. If your test returns an empty array, that is acceptable; if it returns an error, verify your API key and endpoint URL with your administrator before proceeding.

1{
2  "method": "GET",
3  "url": "https://api.yardiyardibreeze.com/v1/units",
4  "headers": {
5    "Authorization": "Bearer <api_key_private>",
6    "Content-Type": "application/json"
7  },
8  "params": {
9    "property_id": "<dynamic_property_id>"
10  }
11}

**For Yardi Voyager (SOAP):** SOAP responses are XML, not JSON. Bubble's native API Connector expects JSON. You need to convert the XML response string into a usable data structure using the Toolbox plugin. If you haven't already, go to Plugins → Add plugins → search 'Toolbox' → Install. In a Workflow triggered after the SOAP API call, add the action **Toolbox: Run JavaScript**. In the script field, write JavaScript that uses the browser's DOMParser to parse the XML string and extract the fields you need: ```javascript var xmlStr = properties.xmlInput; var parser = new DOMParser(); var xmlDoc = parser.parseFromString(xmlStr, 'text/xml'); var units = xmlDoc.getElementsByTagName('UnitRecord'); var result = []; for (var i = 0; i < units.length; i++) { result.push({ unit_id: units[i].getElementsByTagName('UnitId')[0].textContent, unit_number: units[i].getElementsByTagName('UnitNumber')[0].textContent, status: units[i].getElementsByTagName('Status')[0].textContent, rent: units[i].getElementsByTagName('MarketRent')[0].textContent }); } return JSON.stringify(result); ``` Pass the SOAP response body as the `xmlInput` property to this script. Store the returned JSON string in a Bubble custom state, then parse it in subsequent workflow steps to create or update records in Bubble's database. **For Yardi Breeze (REST):** JSON responses parse automatically. Use Bubble's 'Get data from external API' in a workflow to store the results into Bubble data types. **Set up privacy rules (mandatory for both):** Go to **Data** tab → **Privacy**. Select each data type that stores Yardi data (e.g., YardiUnit, YardiResident, YardiWorkOrder). Add privacy rules: - For resident-facing data: 'This User = Creator' or a role-based condition - For manager-facing data: 'Current User's role = Manager' - Block all fields from being visible to unauthenticated users Do not go live without these rules. Yardi data includes tenant PII, lease financials, and unit-level details that must not be publicly accessible.

1// Toolbox Run JavaScript — parse Yardi Voyager SOAP XML response
2var xmlStr = properties.xmlInput;
3var parser = new DOMParser();
4var xmlDoc = parser.parseFromString(xmlStr, 'text/xml');
5var units = xmlDoc.getElementsByTagName('UnitRecord');
6var result = [];
7for (var i = 0; i < units.length; i++) {
8  result.push({
9    unit_id: units[i].getElementsByTagName('UnitId')[0].textContent,
10    unit_number: units[i].getElementsByTagName('UnitNumber')[0].textContent,
11    status: units[i].getElementsByTagName('Status')[0].textContent,
12    rent: units[i].getElementsByTagName('MarketRent')[0].textContent
13  });
14}
15return JSON.stringify(result);

With the API Connector configured and privacy rules in place, you can build the core property management view: a unit availability dashboard. **Set up the data type:** Go to Data tab → Data types → New type → name it 'YardiUnit'. Add fields: unit_number (text), property_name (text), status (text), market_rent (number), bed_count (number), last_synced (date). **Create the sync workflow:** In the Workflow editor, create a workflow triggered by a 'Sync Units' button click (or on page load if the data is stale). Inside the workflow: 1. Call the Yardi API (GET units or the SOAP unit list operation) 2. For Voyager: pass the XML response to the Toolbox JavaScript parser 3. For each unit in the result, use 'Create a new YardiUnit' or 'Make changes to YardiUnit' (searching by unit_id) to upsert the record into Bubble's database 4. Store current date/time in a last_synced field **Build the repeating group:** On the dashboard page, add a Repeating Group. Set Type of content to YardiUnit. Set Data source to 'Do a search for YardiUnit' with constraints on status or property_name as needed. Add columns for unit number, status, market rent, and bedroom count. **Add vacancy filter:** Add a checkbox or dropdown to the page that filters the repeating group by status = 'Vacant'. This gives property managers an instant vacancy view without additional API calls — the data is already in Bubble's database from the last sync. Add a 'Last synced: [last_synced date]' text element to the dashboard so users know how fresh the data is. For high-frequency portfolios, a 'Sync now' button is more cost-effective in Workload Units than auto-syncing on every page load.

**Work order panel:** Add a new page (or tab within the dashboard) for maintenance work orders. Create a YardiWorkOrder data type: work_order_id (text), unit_number (text), description (text), status (text), submitted_date (date), completed_date (date), priority (text). Create a workflow to sync work orders from Yardi (GET work orders endpoint or corresponding SOAP operation). Use the same upsert pattern from Step 5: search for existing records by work_order_id, update if found, create if not. In the workflow editor, build a status-update workflow: when a manager clicks a 'Mark Resolved' button on a work order row, call Yardi's work order update endpoint (POST or PATCH to the work order update operation with the new status value in the XML body or JSON body). After the Yardi call succeeds, update the local YardiWorkOrder record in Bubble's database to match. Add confirmation dialogs: any workflow that writes data back to Yardi should prompt 'Are you sure you want to mark this as resolved?' before firing the API call. This prevents accidental state changes in your enterprise property management system. **Lease expiration alerts:** Create a YardiLease data type: lease_id, tenant_name, unit_number, lease_end_date, status. Sync active leases from Yardi into this data type. On the dashboard, add a conditional section: 'Show leases expiring within 60 days' using a Bubble search constraint: YardiLease's lease_end_date is within 60 days of today AND status = 'Active'. Display these in a warning-highlighted repeating group at the top of the dashboard. For automated alerts, consider a Backend Workflow (requires paid Bubble plan) that runs daily, queries YardiLease records expiring within 30 days, and sends an email via Sendgrid or Postmark to the assigned property manager. This saves managers from manually checking expiration dates and prevents lease renewal gaps in large portfolios. RapidDev's team has built dozens of enterprise property management Bubble apps with integrations to Yardi, Buildium, and CoStar — if you need help architecting the data model or troubleshooting SOAP responses, book a free scoping call at rapidevelopers.com/contact.