How to Integrate Bolt.new with Yardi Voyager

Yardi API access is not self-service. The process requires coordinating with Yardi support and your account manager. Here is what you need to request and what Yardi will provide: First, verify you have an active Yardi Voyager license — this is the property management software itself, with annual licensing fees typically starting in the tens of thousands of dollars for enterprise deployments. If your organization uses Yardi, there will be a Yardi administrator or IT contact who manages the software. Contact your Yardi account manager and request 'REST API access' or 'ILS Web Services API enablement.' Yardi will ask for your intended use case, the technical contact responsible for the integration, and may require a data use agreement. After approval, Yardi provisions an API client for your database instance and provides: client_id (a GUID), client_secret, your database instance name (appears in your Yardi URL), and the REST API base URL for your deployment. If you are building a property management app and don't have Yardi access, consider these alternatives: Buildium has a developer-accessible REST API with a sandbox environment and no enterprise contract requirement. AppFolio's API is similarly more accessible. RentManager and Propertyware also have APIs. These alternatives let you build and test without the Yardi procurement barrier.

Store your Yardi credentials in your Bolt.new project's .env file. All Yardi credentials are server-side only — no NEXT_PUBLIC_ prefix on any of them. The API base URL, client_id, and client_secret are sensitive configuration data that must never appear in browser-accessible code. Yardi's REST API uses OAuth 2.0 Client Credentials flow for server-to-server authentication. Your app calls Yardi's token endpoint with client_id and client_secret, receives a short-lived access token (typically valid for 1 hour), and includes it as a Bearer token in all subsequent API requests. Token refresh must be handled automatically — create a token management utility that caches the current token and refreshes it when expired. The token endpoint URL and scope vary by Yardi deployment. Your Yardi technical contact should provide the exact token URL. Common patterns include the database instance name in the URL path.

1# .env file — all Yardi credentials are server-side only
2# NEVER use NEXT_PUBLIC_ prefix for any Yardi credential
3YARDI_API_BASE_URL=https://your-instance.yardi.com/yardiws/
4YARDI_CLIENT_ID=your-client-id-guid
5YARDI_CLIENT_SECRET=your-client-secret
6YARDI_TOKEN_URL=https://your-instance.yardi.com/yardiws/token
7YARDI_DATABASE=your-database-name
8# Scope varies by Yardi deployment — confirm with your account manager
9YARDI_SCOPE=yardiws

With authentication handled in lib/yardi.ts, build Next.js API routes that fetch property management data from Yardi's endpoints. Yardi's REST API follows standard REST conventions: GET requests for reading data, POST for creating records, PUT for updates. The key endpoints for a tenant portal or property dashboard are: properties list (GET /properties), units for a property (GET /properties/{propertyId}/units), leases (GET /leases or GET /tenants/{tenantId}/leases), and work orders (GET /workorders). The exact endpoint paths vary by Yardi configuration — use your Yardi API documentation (provided when API access is granted) for the authoritative URL structure. All API routes should proxy requests to Yardi, handling authentication transparently. The client (your React components) calls /api/yardi/properties and never knows the underlying Yardi URL exists.

1// app/api/yardi/properties/route.ts
2import { NextResponse } from 'next/server';
3import { yardiRequest } from '@/lib/yardi';
4
5export async function GET() {
6  try {
7    // Endpoint path depends on your Yardi configuration
8    // Consult your Yardi API documentation for exact paths
9    const data = await yardiRequest('/properties', {
10      method: 'GET',
11      headers: { 'Accept': 'application/json' },
12    });
13
14    // Normalize Yardi's response format to what your UI expects
15    // Yardi field names vary by version — check your API docs
16    const properties = Array.isArray(data) ? data : data?.properties ?? data?.value ?? [];
17    const normalized = properties.map((p: Record<string, unknown>) => ({
18      propertyId: p.PropertyID ?? p.id,
19      name: p.PropertyName ?? p.name,
20      address: `${p.AddressLine1 ?? ''}, ${p.City ?? ''}, ${p.State ?? ''}`.trim(),
21      totalUnits: Number(p.TotalUnits ?? 0),
22      occupiedUnits: Number(p.OccupiedUnits ?? 0),
23    }));
24
25    return NextResponse.json({ properties: normalized });
26  } catch (error) {
27    console.error('Yardi properties fetch error:', error);
28    return NextResponse.json({ error: 'Failed to fetch properties from Yardi' }, { status: 500 });
29  }
30}

Work order creation is one of the highest-value features for a tenant portal. Tenants submit maintenance requests through your Bolt app, which creates work orders in Yardi that property managers can then track and assign through Yardi's native workflow. The work order creation endpoint typically accepts: the unit ID or property ID, a category (plumbing, electrical, HVAC, etc.), description, priority level, and contact information. The exact required fields depend on your Yardi configuration and which work order types are enabled. For incoming work orders from Bolt to Yardi, use a POST request with the work order data in the request body. Yardi should return the newly created work order ID, which you store in your database to link the tenant's submission to the Yardi record for status tracking.

1// app/api/yardi/work-orders/route.ts
2import { NextResponse } from 'next/server';
3import { yardiRequest } from '@/lib/yardi';
4
5const PRIORITY_MAP: Record<string, string> = {
6  low: '3',
7  medium: '2',
8  high: '1',
9  emergency: '0',
10};
11
12export async function POST(request: Request) {
13  try {
14    const { unitId, category, description, priority, contactPhone } = await request.json();
15
16    if (!unitId || !category || !description) {
17      return NextResponse.json(
18        { error: 'unitId, category, and description are required' },
19        { status: 400 }
20      );
21    }
22
23    // Field names depend on your Yardi version — consult your API documentation
24    const workOrderPayload = {
25      UnitID: unitId,
26      Category: category,
27      Description: description,
28      Priority: PRIORITY_MAP[priority] ?? '2',
29      ContactPhone: contactPhone ?? '',
30      Status: 'Open',
31    };
32
33    const result = await yardiRequest('/workorders', {
34      method: 'POST',
35      headers: {
36        'Content-Type': 'application/json',
37        'Accept': 'application/json',
38      },
39      body: JSON.stringify(workOrderPayload),
40    });
41
42    const workOrderId = result?.WorkOrderID ?? result?.id ?? result?.workOrderId;
43    return NextResponse.json({ success: true, workOrderId });
44  } catch (error) {
45    console.error('Yardi work order creation error:', error);
46    return NextResponse.json({ error: 'Failed to create work order in Yardi' }, { status: 500 });
47  }
48}

Your Bolt.new app with Yardi integration needs to be deployed for production use. Since Yardi typically operates on corporate networks with IP allowlisting, coordinate with your IT team before deployment. Many Yardi deployments are behind a corporate VPN or firewall, with API access restricted to approved IP addresses. If your Yardi instance is accessible only from the corporate network, your Bolt app's hosting server IP must be added to the Yardi API allowlist. Contact your Yardi system administrator with the IP addresses of your Netlify or Bolt Cloud deployment. For Bolt Cloud or Netlify deployments, the outbound IP addresses may be variable (serverless functions use shared infrastructure). In this case, your Yardi administrator may need to use a broader IP range allowlist or you may need to set up a dedicated proxy server with a static IP. This is a common enterprise integration challenge — discuss the options with your IT team and Yardi support. Deploy to Netlify or Bolt Cloud and add all YARDI_* environment variables to your hosting provider's dashboard. Test each API route after deployment to confirm connectivity to Yardi's servers from the hosting infrastructure.