> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getsmartalex.com/llms.txt
> Use this file to discover all available pages before exploring further.

# SmartAlex vs VAPI for real estate (2026)

> An honest, real-estate specific comparison of SmartAlex vs VAPI: SmartAlex ships lead capture, viewing bookings, and campaigns out of the box, while VAPI gives you a raw voice API to assemble yourself.

If you run a brokerage, a property team, or a solo agent business, the real question is not "which AI has the nicest voice." It is "which one actually books viewings, captures the buyer who called at 9pm, and pushes that lead into a pipeline my team already works." SmartAlex and VAPI answer that question very differently. This page is a straight comparison for real estate, including where VAPI is genuinely the better pick.

<Info>
  Short version: **SmartAlex is a full business platform** with a real estate plan, lead capture, booking, and campaigns already wired together. **VAPI is a developer-first voice API** you assemble into a product yourself. If you want to ship an inbound-and-outbound real estate setup this week, SmartAlex is faster. If you have engineers and want to hand-build every layer, VAPI gives you more raw control.
</Info>

## Who each one is for

<CardGroup cols={2}>
  <Card title="Choose SmartAlex if" icon="building">
    You want a working real estate voice assistant without gluing five products together. You value a booking flow, a deals pipeline, outbound nurture campaigns, and an embeddable website widget that already exist. You may want an AI assistant (Claude, ChatGPT, Cursor) to operate the account for you over MCP.
  </Card>

  <Card title="Choose VAPI if" icon="code">
    You have developers and want to hand-assemble the stack: swap speech and language models independently, run a custom or self-hosted language model, build multi-agent squads, and wire your own CRM, calendar, and campaign logic through their client and server SDKs.
  </Card>
</CardGroup>

## The comparison, capability by capability

<Note>
  We do not publish invented competitor benchmarks or per-minute prices here. VAPI bills per component (speech to text, language model, text to speech, plus telephony), so its blended cost depends on the stack you assemble. Check VAPI's own pricing for current figures. For SmartAlex figures, see [pricing](/pricing).
</Note>

| Capability                   | SmartAlex                                                                        | VAPI                                                                                                |
| ---------------------------- | -------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
| Setup model                  | No-code Studio, plus auto-build an agent from a URL in under 60s                 | Code the agent through the API and SDKs                                                             |
| Real estate vertical plan    | Yes, a dedicated Real Estate plan                                                | None, you build the vertical yourself                                                               |
| Lead capture and CRM         | Built-in contacts and a deals pipeline                                           | Bring your own CRM                                                                                  |
| Viewing and showing bookings | Built-in calendar tools (Google Calendar, Calendly, custom iCal via Power Tools) | Wire your own function calls to a calendar                                                          |
| Outbound nurture campaigns   | Outbound Campaigns add-on (scheduling, retries, disposition tracking)            | Build the orchestration yourself                                                                    |
| Website capture widget       | Paste one script tag, or drop in a React component                               | Build a web client with the SDK                                                                     |
| Programmatic control         | Live 28-tool MCP server, plus Custom HTTP Tools                                  | Rich client SDKs (Web, iOS, Android, React Native, Flutter) and server SDKs (Python, Node.js, Ruby) |
| Telephony                    | Managed for you                                                                  | Bring your own carrier or SIP                                                                       |
| Voice model choice           | Curated, high-accuracy speech and voice models, kept abstracted                  | Swap speech and language models independently, custom language model support                        |
| Multi-agent squads           | One active agent per widget config                                               | Multi-agent squads                                                                                  |
| Analytics                    | Built-in dashboards                                                              | Build your own                                                                                      |
| Pricing shape                | Predictable monthly plan plus included minutes                                   | Per-minute plus components plus telephony                                                           |

Both are strong tools. The honest divide is **assembled-for-you versus assemble-it-yourself**. VAPI's documentation is among the deepest in the category, and its model-swapping and squad features are real advantages if you want to engineer a bespoke system. SmartAlex trades some of that low-level control for a platform that already does the real estate jobs below.

## The three real estate jobs, and how each handles them

### Inbound buyer and seller capture

The lead that calls after hours is the one you lose. With VAPI you would build the inbound agent, then separately build the place the captured lead lands and the logic that routes it. With SmartAlex, an inbound agent answers 24/7, asks whether the caller is buying or selling, captures name and contact, and writes a **contact** plus a **deal** into the pipeline automatically. Your website gets the same coverage: paste the widget and site visitors can talk or type to Alex without leaving the page.

### Viewing and showing bookings

Booking is where a raw voice API shows the most assembly work. On SmartAlex, calendar booking is a built-in agent tool. With the **Power Tools** add-on (\$29/month) the agent can reach Google Calendar, Calendly, or a custom iCal feed to offer real slots and confirm a viewing during the call. On VAPI you would implement the function calls, host the endpoint, and manage the calendar integration yourself.

### Lead qualification

Real estate leads are only useful when qualified: budget, timeline, financing status, and target area. On SmartAlex you configure these as questions in Studio, the answers attach to the contact and deal, and the pipeline stage updates as the conversation progresses. On VAPI you define the extraction schema and function calls in code and persist the results into your own store.

```mermaid theme={null}
flowchart LR
  A[Buyer or seller calls, or opens site widget] --> B[Alex qualifies: buy or sell, budget, timeline, area]
  B --> C{Wants a viewing?}
  C -- Yes --> D[Alex offers real calendar slots and books it]
  C -- No --> E[Alex captures contact for nurture]
  D --> F[Contact and deal created in pipeline]
  E --> F
  F --> G[Outbound Campaigns follows up automatically]
```

## Pricing shape for a real estate team

SmartAlex uses predictable monthly plans with included minutes, not per-minute assembly math. The **Professional** plan is \$99/month with 250 included minutes, one number, and one agent. There is also a dedicated **Real Estate** plan (\$3,000/month) built for higher-volume brokerages. The two add-ons most real estate teams reach for:

* **Outbound Campaigns**, \$49/month, for nurture and follow-up calling with scheduling and disposition tracking.
* **Power Tools**, \$29/month, which unlocks the calendar and payment tools, Custom HTTP Tools, and the Developer Portal where MCP API keys are issued.

See [pricing](/pricing) and [add-ons](/essentials/add-ons) for current figures and what each plan includes. VAPI's total cost is per-minute plus each model component plus your telephony, so compare on the specific stack you would assemble.

## Operate the account with an AI assistant (MCP)

This is where SmartAlex leans into being agent-native. You can connect an AI client (Claude Code, Cursor, ChatGPT) to the live SmartAlex MCP server and drive the account in plain language: create the listing-inquiry agent, launch a follow-up campaign, check which viewings booked. Connect the hosted server with one command:

```bash theme={null}
claude mcp add --transport http smartalex https://api.getsmartalex.com/functions/v1/mcp-server
```

Then prompt naturally:

* "Create a real estate inbound agent that qualifies buyers by budget, area, and timeline, then books viewings on my Google Calendar."
* "Launch an Outbound Campaign to every contact in the pipeline that stalled at the viewing stage."
* "Show me which deals changed stage this week and the calls behind them."

MCP keys are issued in the Developer Portal and require the Power Tools add-on plus a super-admin role. Full detail: [MCP overview](/mcp/overview) and [getting started](/mcp/getting-started).

## Put a capture widget on your listing site

The website widget is byte-identical across styles because it reads its published config from the server. Paste this just before the closing `</body>` tag on your site (Webflow, WordPress, Shopify, Wix, Squarespace, or any HTML page):

```html theme={null}
<!-- SmartAlex Widget -->
<script
  src="https://api.getsmartalex.com/storage/v1/object/public/widget-assets/smartalex-widget.js"
  data-tenant-id="YOUR_TENANT_ID"
  async>
</script>
```

For a Next.js listing site, inject it from the root layout instead:

```jsx theme={null}
import { useEffect } from 'react';

export default function Layout({ children }) {
  useEffect(() => {
    const script = document.createElement('script');
    script.src = 'https://api.getsmartalex.com/storage/v1/object/public/widget-assets/smartalex-widget.js';
    script.setAttribute('data-tenant-id', 'YOUR_TENANT_ID');
    script.async = true;
    document.body.appendChild(script);
    return () => { document.body.removeChild(script); };
  }, []);
  return <>{children}</>;
}
```

Your `YOUR_TENANT_ID` is shown in the widget code panel inside SmartAlex. Restyling the widget in Studio never requires re-pasting. Setup steps: [widget install](/essentials/widget-install).

## Where VAPI is the honest winner

Being fair matters. Pick VAPI over SmartAlex when you want to swap speech or language models independently, run a custom or self-hosted language model, build multi-agent squads with fine-grained routing, or ship native mobile voice with their client SDKs. VAPI is a developer's toolkit, and if you have the engineering appetite to assemble the CRM, booking, and campaign layers yourself, it gives you more low-level control than a platform does.

<Tip>
  Many real estate teams do not want to build those layers. They want the missed after-hours buyer captured, the viewing booked, and the lead in a pipeline their agents already work. That is the case where SmartAlex ships faster.
</Tip>

## Related

<CardGroup cols={2}>
  <Card title="Real estate use case" icon="house" href="/use-cases/real-estate">
    How teams run inbound capture, bookings, and qualification on SmartAlex.
  </Card>

  <Card title="SmartAlex vs VAPI" icon="scale-balanced" href="/comparisons/smartalex-vs-vapi">
    The full platform comparison beyond real estate.
  </Card>

  <Card title="VAPI alternative" icon="arrows-repeat" href="/comparisons/vapi-alternative">
    Why teams move from a raw voice API to a platform.
  </Card>

  <Card title="Best AI voice agent platforms" icon="trophy" href="/comparisons/best-ai-voice-agent-platforms">
    Where SmartAlex, VAPI, Retell, and others land.
  </Card>
</CardGroup>
