How to Build a Real Estate Listing Monitor with Paradime, OpenClaw, and Bolt Scheduling

Catch new listings before the competition — with a structured, incident-friendly pipeline that alerts you daily on Slack.

Real estate moves fast. A listing that matches your criteria at 7 AM could be under contract by noon. Manually refreshing Zillow or Rightmove every morning is unsustainable — and it doesn't scale.

This guide walks you through building an automated real estate listing monitor using Paradime for pipeline orchestration, OpenClaw for AI-powered web search and listing extraction, and Bolt scheduling to run the whole thing on a daily cron. You'll get structured steps, a decision tree for common failures, and a "time to first clue" mindset when things go wrong.

By the end, you'll have a system that:

• Searches for listings matching your criteria (location, price, bedrooms)

• Compares against previously seen listings

• Alerts you on Slack when new matches appear

• Runs every morning at 7 AM — automatically

What Is Paradime?

Paradime is an all-in-one AI platform that replaces dbt Cloud™. It provides a dbt™-native workspace where analytics teams can code, ship, fix, and scale data pipelines for analytics and AI.

Key capabilities relevant to this guide:

Bolt is the engine we'll use to schedule our monitoring script. It supports Schedules as Code via a paradime_schedules.yml file in your dbt™ project root, and it can run Python scripts with full Poetry dependency management.

What Is OpenClaw?

OpenClaw is an open-source, self-hosted AI agent that runs on your own devices. It connects to messaging surfaces you already use (WhatsApp, Telegram, Slack, Discord, and more) and extends its capabilities through a plugin SDK.

For real estate monitoring, OpenClaw gives us two critical tools:

1. web_search — Search the web using Brave Search API, Firecrawl, Gemini, Grok, Perplexity, or Kimi. Returns structured results with configurable freshness filters.

2. web_fetch — HTTP fetch with readable content extraction (HTML → markdown/text). Useful for pulling listing details from property pages.

OpenClaw's plugin architecture follows four layers:

Figure 1: OpenClaw plugin architecture — from manifest discovery to runtime tool consumption.

The plugin SDK exposes registration surfaces like api.registerTool(), api.registerHook(), and channel-specific subpaths (openclaw/plugin-sdk/slack, etc.).

Setup: openclaw-sdk + Web Search/API

Prerequisites

Before you begin, ensure you have:

• A Paradime account with Bolt access

• A running OpenClaw instance (local or server)

• A Slack workspace with an incoming webhook or bot app configured

• A web search API key (Brave Search recommended — includes $5/month free credit)

• Python 3.10+ and Poetry installed

Step 1: Configure OpenClaw Web Search

OpenClaw auto-detects search providers in this order: Brave → Gemini → Grok → Kimi → Perplexity → Firecrawl. Set your preferred provider:

Or set the environment variable directly:

The OpenClaw web search config looks like this:

Step 2: Configure Slack Integration

For sending alerts from your Python script, you'll use a Slack Incoming Webhook. Create one at Slack API: Incoming Webhooks.

If you also want OpenClaw to communicate directly via Slack (Socket Mode):

Required bot scopes: chat:write, channels:history, channels:read, im:history, im:read, im:write, app_mentions:read, reactions:read.

Step 3: Set Up the dbt™ Project Structure

Your project directory should look like:

Step 4: Install Dependencies with Poetry

The Monitoring Script

Here's the complete Python script that ties OpenClaw's web search to Slack notifications:

How the Script Works — Decision Flow

Figure 2: Decision flow for the daily listing monitor — from cron trigger to Slack alert.

Environment Variables

Configure these three environment variables in Paradime's Bolt Schedule settings:

Setting Environment Variables in Paradime

1. Navigate to Settings → Workspaces → Environment Variables

2. In the Bolt Schedules section, click Add New

3. Enter each Key/Value pair and click Save (💾)

Tip: You can also bulk-upload environment variables via CSV. The CSV must have header columns Key and Value — no extra spaces or punctuation.

Bolt Schedule: Cron Daily 7 AM

Option A: Schedules as Code (Recommended)

Create paradime_schedules.yml in your dbt™ project root:

Key details:

• poetry install must be the first command — it creates the virtual environment and installs dependencies

• "0 7 * * *" means 7:00 AM every day in the specified timezone

• SLA of 15 minutes triggers an alert if the run hasn't completed by 7:15 AM

• Paradime auto-refreshes schedules from the default branch every 10 minutes

Option B: UI-Based Schedule

1. Navigate to Bolt → Create Schedule

2. Set trigger type to Scheduled Run

3. Enter cron expression: 0 7 * * *

4. Select timezone: America/Chicago

5. Add commands: poetry install, then poetry run python scripts/monitor_listings.py

6. Configure notifications under the Notification Settings tab

7. Click Deploy

Schedule Lifecycle

Figure 3: End-to-end sequence from Bolt cron trigger to Slack alerts.

Monitoring and Debugging

Time to First Clue: Where to Look

When a run fails, Paradime Bolt gives you three layers of logs — each designed to get you from "something broke" to "here's what happened" as fast as possible:

Accessing Logs

1. Navigate to Bolt → click your real-estate-monitor schedule

2. Click the specific Run in the Run History list

3. Scroll to Logs and Artifacts

4. Click the command (e.g., poetry run python scripts/monitor_listings.py) to expand

Run History Dashboard

The Bolt overview screen shows all schedules with their:

• Status (Passed / Failed / Running)

• Last Run and Next Run timestamps

• Duration trends

• Trigger type (Cron, API, Merge, On Completion)

Key Artifacts

dbt Core™ generates artifacts on each run:

• manifest.json — full project graph

• run_results.json — execution results per node

• sources.json — source freshness snapshots

For Python scripts, monitor:

• Exit codes (non-zero = failure in Bolt)

• seen_listings.json — verify deduplication state is updating

Adding a Health Check to Your Script

Extend the script with structured logging for fast debugging:

Troubleshooting Common Issues

Use this decision tree to diagnose failures fast:

Figure 4: Decision tree for diagnosing failed Bolt runs — follow the branches to your fix.

Issue-by-Issue Reference

1. poetry install fails

Symptoms: Bolt run fails on the first command.

Checklist:

• pyproject.toml exists in the project root

• Python version constraint matches Bolt environment

• No private package indexes requiring authentication

Minimal fix:

2. Missing environment variables

Symptoms: KeyError: 'OPENCLAW_API_KEY' in console logs.

Fix:

1. Navigate to Settings → Workspaces → Environment Variables

2. Confirm the variable exists in the Bolt Schedules section (not Code IDE)

3. Key names are case-sensitive: OPENCLAW_API_KEY ≠ openclaw_api_key

3. OpenClaw Gateway returns empty results

Symptoms: Script runs successfully but finds zero listings every day.

Checklist:

• Verify web_search is enabled: openclaw configure --section web

• Test search manually: curl -X POST http://localhost:5005/v1/responses ...

• Check that freshness filter isn't too restrictive

• Confirm the search provider API key hasn't expired

Reproduce locally:

4. Slack alerts not arriving

Symptoms: Script logs "Slack alert sent" but no message appears.

Checklist:

• Test webhook independently: curl -X POST -H 'Content-Type: application/json' -d '{"text":"test"}' $SLACK_WEBHOOK_URL

• Check Slack channel hasn't been archived

• Verify the webhook app is still installed in your workspace

• Check for Slack API rate limits (1 message/second per webhook)

5. Duplicate alerts (seen_listings.json not persisting)

Symptoms: The same listings trigger alerts every run.

Root cause: Bolt runs in ephemeral environments — file system state doesn't persist between runs.

Fix options:

• Store seen_listings.json in your Git repo (commit after each run via a post-run hook)

• Use a database table (Snowflake, BigQuery, Postgres) to store seen hashes

• Use an S3/GCS bucket for state persistence

6. SLA breach notifications firing

Symptoms: You receive SLA alerts even though the run eventually succeeds.

Fix: Increase the sla_minutes value in your schedule configuration:

Wrapping Up

You now have a fully automated real estate listing monitor that:

1. Runs daily at 7 AM via Paradime Bolt's cron scheduler

2. Searches the web for matching listings using OpenClaw's web_search tool

3. Deduplicates results against a persistent seen-listings store

4. Alerts you on Slack only when new matches appear

5. Self-monitors with Bolt's built-in logging, notifications, and SLA tracking

Figure 5: High-level architecture of the real estate listing monitor pipeline.

What to Do Next

• Expand search criteria: Add multiple locations or property types by making SEARCH_CRITERIA_JSON an array

• Persist state in your warehouse: Replace the JSON file with a dbt™ incremental model for reliable deduplication

• Add enrichment: Use OpenClaw's web_fetch tool to pull full listing details (photos, descriptions, agent info) for richer Slack alerts

• Set up a secondary alert channel: Configure Paradime Bolt's Microsoft Teams notifications as a backup

• Track trends over time: Build dbt™ models on top of your listing data to monitor price trends, inventory levels, and days-on-market patterns

Useful Links

• Paradime Documentation

• Paradime Bolt Schedules as Code

• Paradime Bolt Environment Variables

• Paradime Bolt Python Scripts

• Paradime Bolt Notification Settings

• Paradime Bolt Trigger Types

• OpenClaw GitHub Repository

• OpenClaw Documentation

• OpenClaw Web Tools

• OpenClaw Plugin SDK

• OpenClaw Slack Integration

• Crontab Guru (Cron Expression Helper)