How to Integrate Retool with Yardi

Yardi API access is not self-service — it must be arranged through Yardi directly. Contact Yardi Support at your organization's support portal (support.yardi.com) or speak with your Yardi Account Manager to request API credentials. Specify that you are building a Retool integration and need API access for the Yardi products you use. Yardi will provide credentials and documentation specific to your product. Understanding which API you are working with is essential before configuring Retool. Yardi Voyager (enterprise) uses a SOAP-based web service — requests are XML-formatted POST calls to a SOAP endpoint. The Voyager API base URL follows the pattern https://{yardi-server}/Voyager/webservice/itfYardiGuestCard.asmx (endpoint names vary by integration type — resident data, work orders, and financial data each have separate WSDL endpoints). Yardi Breeze (SMB) uses a more modern REST API with JSON responses and API key authentication. RentCafe (the resident-facing portal platform) has its own API for marketing and leasing data. Your Yardi Account Manager will provide the specific endpoint URLs, WSDL files, and authentication parameters for your account. Store all Yardi credentials in Retool Settings → Configuration Variables: create YARDI_USERNAME, YARDI_PASSWORD, YARDI_SERVER_NAME, YARDI_DATABASE, and YARDI_ENTITY as separate secret variables. This structure matches the Voyager API's required parameters.

In Retool, click the Resources tab and Add Resource. Select REST API. Name it 'Yardi API'. For the Base URL, enter the base URL of your Yardi server. For Yardi Voyager (cloud-hosted), this is typically https://{your-yardi-server-name}.yardipcv.com — your Yardi Account Manager will confirm the exact hostname. For on-premises Voyager deployments, the URL is your internal server address (e.g., https://yardi.yourcompany.com). For Yardi Breeze, the API URL is typically https://api.yardibreeze.com or similar — confirm with Yardi documentation. For Voyager SOAP endpoints, the Authentication method depends on how your integration is configured. Many Voyager integrations embed credentials in the SOAP XML body rather than in HTTP headers. In the Retool resource, select 'No Auth' as the authentication type and include credentials in the query body. For Yardi Breeze REST API, select API Key authentication with the header name and value provided by Yardi. Add a Content-Type header: for SOAP requests, use text/xml; charset=utf-8; for REST/JSON, use application/json. Add an Accept header set to text/xml for SOAP or application/json for REST. Click Save Changes. Because Yardi Voyager's SOAP interface embeds authentication in every request body, you will configure credential substitution in each query using configuration variable references rather than resource-level authentication headers.

Yardi Voyager's SOAP API uses XML request envelopes — each query is a POST request with an XML body following the specific WSDL schema for that operation. To retrieve resident (tenant) data, create a query in the Retool Code panel, select the Yardi API resource, set Method to POST, and set Path to the specific SOAP endpoint path (e.g., /Voyager/webservice/itfResidentData.asmx or the endpoint provided in your Yardi documentation). In the Body section, set Body Type to Raw and Body to an XML SOAP envelope. The SOAP envelope structure for Yardi Voyager embeds authentication credentials (server name, database, username, password, and entity) in the SOAP body within a 'Credentials' element — not in HTTP headers. Construct the SOAP body dynamically using Retool's {{ }} syntax to inject configuration variable values. In the Response Transformer (Advanced tab), write a JavaScript transformer to parse the XML response. Retool's REST API queries return XML responses as strings — parse them using the browser's DOMParser or a JSON transformation. Use the pattern: const parser = new DOMParser(); const xmlDoc = parser.parseFromString(data, 'text/xml') to access XML nodes. Extract resident records from the parsed XML and return a flat array of JavaScript objects for use in Retool Table components.

1// Yardi Voyager SOAP Request body — configure as Raw Body
2`<?xml version="1.0" encoding="utf-8"?>
3<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4               xmlns:xsd="http://www.w3.org/2001/XMLSchema"
5               xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
6  <soap:Body>
7    <GetResidents xmlns="http://tempuri.org/">
8      <UserName>{{ retoolContext.configVars.YARDI_USERNAME }}</UserName>
9      <Password>{{ retoolContext.configVars.YARDI_PASSWORD }}</Password>
10      <ServerName>{{ retoolContext.configVars.YARDI_SERVER_NAME }}</ServerName>
11      <Database>{{ retoolContext.configVars.YARDI_DATABASE }}</Database>
12      <PlatformType>SQL Server</PlatformType>
13      <InterfaceEntity>{{ retoolContext.configVars.YARDI_ENTITY }}</InterfaceEntity>
14      <YardiPropertyId>{{ propertySelect.value }}</YardiPropertyId>
15    </GetResidents>
16  </soap:Body>
17</soap:Envelope>`

Yardi Voyager returns data as XML, which requires parsing in Retool's JavaScript transformer. Create a transformer attached to your resident data query (in the query's Advanced tab, enable the transformer toggle). Write a parser that extracts resident elements from the SOAP response XML. The transformer receives the raw XML string in the 'data' variable. Use DOMParser to traverse the XML DOM and extract fields. Map each resident node's child elements to JavaScript object properties: tenant code, name, unit number, property code, lease start date, lease end date, market rent, actual charges, and resident status. With parsed data available, build the dashboard UI. Drag a Select component for property selection — populate it from a separate Yardi query that fetches all properties (/GetPropertyList equivalent). When the property selection changes, trigger the resident data query via event handler. Drag a Table component, bind its data to the resident query's transformer output ({{ getResidents.data }}), and configure columns: unit, tenant_name, lease_end, market_rent, status (with conditional formatting: 'Current' in green, 'Notice' in yellow, 'Past' in red). Add a search Text Input bound to the Table's search property. For work orders, create a separate SOAP query for the Yardi maintenance interface and display results in a second tab. For complex multi-property Yardi integrations with custom data transformations, RapidDev can help design the full query architecture and XML parsing layer.

1// Transformer: parse Yardi Voyager XML resident response
2// 'data' is the raw XML string from the SOAP response
3try {
4  const parser = new DOMParser();
5  const xmlDoc = parser.parseFromString(data, 'text/xml');
6  const residents = xmlDoc.getElementsByTagName('Resident');
7  const result = [];
8
9  for (let i = 0; i < residents.length; i++) {
10    const r = residents[i];
11    const getText = (tag) => r.getElementsByTagName(tag)[0]?.textContent || '';
12    result.push({
13      unit: getText('UnitCode'),
14      tenant_code: getText('TenantCode'),
15      tenant_name: getText('Name'),
16      lease_start: getText('LeaseFrom'),
17      lease_end: getText('LeaseTo'),
18      market_rent: parseFloat(getText('MarketRent')) || 0,
19      status: getText('Status'),
20      property: getText('PropertyCode')
21    });
22  }
23  return result;
24} catch (e) {
25  return [{ error: 'XML parse error: ' + e.message }];
26}

Extend the dashboard with maintenance and performance views. For work orders, create a second SOAP query targeting Yardi's work order or service request interface. The Yardi SOAP endpoint for work orders varies by Voyager module — common options are GetWorkOrders, GetServiceRequests, or similar depending on your Voyager configuration. Follow the same SOAP envelope pattern as the resident query, substituting the operation name and parameters. Work order data typically returns: work order number, unit code, description, priority (Emergency, Routine, Priority), status (New, Assigned, Completed), assigned vendor, date created, and scheduled date. Add a second tab to your dashboard's Tab Container labeled 'Maintenance'. Drag a Table component bound to the work order query data. Configure column formatting: priority 'Emergency' in red, 'Priority' in orange, 'Routine' in blue. Add days-open as a calculated column using a JavaScript transformer: const daysOpen = Math.floor((Date.now() - new Date(row.created_date).getTime()) / (1000 * 60 * 60 * 24)). For portfolio metrics, create a JavaScript transformer query that aggregates the resident data: calculates occupancy rate as (occupied units / total units * 100), total scheduled charges, delinquent balance, and expiring leases count. Display these in a Stats component row at the top of the dashboard. Add a Bar Chart component showing unit availability by property using the aggregated query output.

1// Transformer: aggregate Yardi resident data into portfolio metrics
2const residents = getResidents.data || [];
3const total = residents.length;
4const occupied = residents.filter(r => r.status === 'Current').length;
5const expiringSoon = residents.filter(r => {
6  if (!r.lease_end) return false;
7  const daysLeft = Math.floor(
8    (new Date(r.lease_end) - new Date()) / (1000 * 60 * 60 * 24)
9  );
10  return daysLeft >= 0 && daysLeft <= 60;
11}).length;
12const totalRent = residents
13  .filter(r => r.status === 'Current')
14  .reduce((sum, r) => sum + (r.market_rent || 0), 0);
15
16return {
17  occupancy_rate: total > 0 ? ((occupied / total) * 100).toFixed(1) + '%' : '0%',
18  occupied_units: occupied,
19  total_units: total,
20  expiring_60_days: expiringSoon,
21  total_scheduled_rent: `$${totalRent.toLocaleString()}`
22};