Real estate agents spend 60-70% of their time on administrative tasks instead of closing deals. This n8n workflow automates the entire sales process—from property appraisal to settlement—using AI to manage client correspondence, supplier scheduling, and buyer negotiations. You'll learn how to build a system that operates 24/7, coordinates multiple suppliers automatically, and only charges a success fee when properties sell.
The Problem: Manual Real Estate Operations Kill Productivity
Real estate agents juggle dozens of moving parts for each property listing. A single sale requires coordinating photographers, conveyancers, printers, auction agents, and buyers—all while maintaining constant client communication.
Current challenges:
- Manual scheduling of 5-8 suppliers per property creates bottlenecks
- Email overload from buyers, clients, and suppliers (50+ emails per listing)
- Missed deadlines on critical path items (contracts, photography, advertising)
- After-hours buyer inquiries go unanswered for 12+ hours
- Sensitive client data exposed through unverified email communications
Business impact:
- Time spent: 15-20 hours per week on administrative coordination
- Revenue loss: Agents handle 30% fewer listings due to admin burden
- Client satisfaction: 24-48 hour response delays damage relationships
- Security risk: Unauthorized access to client financial documents
The Solution Overview
This n8n workflow creates an AI-powered real estate agent that automates the entire sales pipeline. The system captures property details through a web interface, generates appraisals using Australian property data APIs (CoreLogic, PriceFinder, PropTrack), and orchestrates supplier workflows automatically. AI handles all client and buyer correspondence while maintaining strict email verification protocols. The workflow tracks critical deadlines and "chases up" suppliers to keep sales on schedule.
What You'll Build
This automation handles every stage of the real estate sales process with minimal human intervention.
| Component | Technology | Purpose |
|---|---|---|
| Client Interface | Web form (mobile responsive) | Capture property address, sale type, advertising preferences |
| Property Valuation | CoreLogic/PriceFinder/PropTrack APIs | Generate automated appraisals for Australian properties |
| AI Correspondence | OpenAI GPT-4 + n8n AI Agent | Handle 24/7 client and buyer inquiries with context awareness |
| Supplier Coordination | Sequential scheduling system | Automate photographer → conveyancer → printer → agent bookings |
| Email Verification | Custom validation logic | Prevent unauthorized access to sensitive client data |
| Deadline Management | Timer nodes + reminder system | Track critical path and send automated follow-ups |
| Payment Processing | Business bank account API | Handle pre-payments and success fee collection |
| Document Storage | Database integration | Store contracts, media, ownership proofs for AI training |
Prerequisites
Before starting, ensure you have:
- n8n instance (cloud or self-hosted with webhook support)
- OpenAI API account with GPT-4 access
- Australian property data API credentials (CoreLogic, PriceFinder, or PropTrack)
- Email service with SMTP/API access (SendGrid, Mailgun, or Gmail)
- Database system (PostgreSQL, Supabase, or Airtable)
- Google Maps API key for Australian address autocomplete
- Stripe or business banking API for payment processing
- Basic JavaScript knowledge for Function nodes and data transformation
Step 1: Set Up Client Data Capture
The workflow begins when a client submits their property details through a web form. This triggers the entire automation sequence.
Configure the Webhook Trigger
- Add a Webhook node as your workflow entry point
- Set HTTP Method to POST
- Set Path to
/real-estate-intake - Enable "Respond to Webhook" for immediate user feedback
Node configuration:
{
"httpMethod": "POST",
"path": "real-estate-intake",
"responseMode": "responseNode",
"options": {
"allowedOrigins": "https://yourdomain.com"
}
}
Extract and validate incoming data:
Add a Function node to parse the webhook payload:
const data = $input.item.json.body;
return {
json: {
address: data.address,
saleType: data.saleType, // "Private Treaty", "Auction", etc.
saleDate: data.saleDate,
advertisingLocations: data.advertisingLocations, // Array
clientEmail: data.clientEmail,
timestamp: new Date().toISOString()
}
};
Why this works:
The webhook creates a public endpoint that your web form posts to. By extracting and structuring data immediately, you create a clean data object that flows through the entire workflow. The timestamp enables deadline tracking later in the process.
Step 2: Generate Property Appraisal
Once you have the property address, query Australian property data APIs to generate an automated valuation.
Configure HTTP Request Node for Property Data
- Add HTTP Request node
- Set Method to GET
- URL:
https://api.corelogic.com.au/property/{{$json.address}} - Add Authentication header with your API key
Aggregate multiple data sources:
Use a Merge node to combine data from CoreLogic, PriceFinder, and PropTrack:
// Function node to calculate average valuation
const coreLogicValue = $input.item.json.corelogic.estimatedValue;
const priceFinderValue = $input.item.json.pricefinder.valuation;
const propTrackValue = $input.item.json.proptrack.estimate;
const averageValue = (coreLogicValue + priceFinderValue + propTrackValue) / 3;
return {
json: {
address: $json.address,
estimatedValue: Math.round(averageValue),
dataSource: "CoreLogic, PriceFinder, PropTrack",
confidence: "High",
comparableSales: $json.corelogic.recentSales
}
};
Why this approach:
Australian property valuations vary significantly between providers. Averaging three sources gives clients confidence in the appraisal accuracy. The comparable sales data provides supporting evidence for the valuation.
Step 3: Implement AI Email Verification
Before sending sensitive documents, verify the client's email address to prevent unauthorized access.
Create verification workflow:
- Add a Function node to generate a unique verification token
- Store token in database with 24-hour expiration
- Send verification email with clickable link
- Create separate webhook to handle verification clicks
Token generation logic:
const crypto = require('crypto');
const token = crypto.randomBytes(32).toString('hex');
return {
json: {
clientEmail: $json.clientEmail,
verificationToken: token,
expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
verified: false
}
};
Email verification template:
Subject: Verify your email for property listing at {{address}}
Click here to verify your email and receive your property appraisal:
https://yourdomain.com/verify?token={{verificationToken}}
This link expires in 24 hours.
Why this matters:
Real estate transactions involve sensitive financial documents and ownership proofs. Email verification prevents malicious actors from claiming to be the client and accessing confidential information. The 24-hour expiration limits the attack window.
Step 4: Build the AI Correspondence System
The AI agent handles all client and buyer inquiries using GPT-4 with context from your database.
Configure OpenAI Agent Node
- Add AI Agent node
- Select GPT-4 model
- Set system prompt with real estate context
- Connect to your database for property information retrieval
System prompt configuration:
You are an AI real estate assistant for Australian properties. You have access to:
- Property details and appraisals
- Sale timelines and inspection dates
- Supplier schedules (photographer, conveyancer, printer, auction agent)
- Buyer inquiry history
Rules:
1. NEVER discuss financial details, ownership documents, or contracts unless the email is verified
2. For unverified emails, respond: "Please verify your email first. Check your inbox for the verification link."
3. Provide inspection times, property features, and general sale information to all inquiries
4. For verified clients, provide full access to contracts, schedules, and financial information
5. Use Australian English spelling and real estate terminology
6. Be professional but conversational
Current property context: {{propertyData}}
Email verification status: {{verificationStatus}}
Connect to email monitoring:
Add an Email Trigger node (IMAP) to monitor your real estate inbox:
{
"mailbox": "INBOX",
"postProcessAction": "mark",
"options": {
"customEmailConfig": "imap.gmail.com:993",
"allowUnauthorizedCerts": false
}
}
Route to AI based on verification status:
// Function node to check verification
const senderEmail = $json.from.value[0].address;
const verifiedEmails = $('Database').all().map(item => item.json.clientEmail);
if (verifiedEmails.includes(senderEmail)) {
return {
json: {
...item.json,
verified: true,
allowSensitiveInfo: true
}
};
} else {
return {
json: {
...item.json,
verified: false,
allowSensitiveInfo: false
}
};
}
Why this works:
The AI agent maintains context across all conversations by querying your database for property-specific information. The verification check runs before every response, ensuring sensitive data never leaks to unverified email addresses. This creates a secure, 24/7 communication system that handles 90% of inquiries without human intervention.
Step 5: Automate Supplier Coordination
Once the client signs the agency agreement and provides ownership documents, the system schedules suppliers in sequence.
Sequential scheduling logic:
// Function node to determine supplier order
const saleType = $json.saleType;
const saleDate = new Date($json.saleDate);
const today = new Date();
// Calculate working backwards from sale date
const daysUntilSale = Math.floor((saleDate - today) / (1000 * 60 * 60 * 24));
const schedule = {
photographer: {
dueDate: new Date(today.getTime() + 2 * 24 * 60 * 60 * 1000), // 2 days
status: 'pending'
},
conveyancer: {
dueDate: new Date(today.getTime() + 7 * 24 * 60 * 60 * 1000), // 7 days for contracts
status: 'pending'
},
printer: {
dueDate: new Date(saleDate.getTime() - 21 * 24 * 60 * 60 * 1000), // 3 weeks before sale
status: 'pending'
},
auctionAgent: saleType === 'Auction' ? {
dueDate: new Date(saleDate.getTime() - 7 * 24 * 60 * 60 * 1000), // 1 week before
status: 'pending'
} : null
};
return { json: schedule };
Photographer coordination:
Add HTTP Request node to email photographer database:
{
"method": "POST",
"url": "https://api.sendgrid.com/v3/mail/send",
"body": {
"to": "{{$json.photographerEmail}}",
"subject": "New Property Photography Assignment - {{$json.address}}",
"text": "Property: {{$json.address}}
Client: {{$json.clientName}}
Due date: {{$json.photographer.dueDate}}
Please confirm appointment time and upload media to: https://yourdomain.com/upload/{{$json.propertyId}}"
}
}
Deadline tracking with timers:
Add Schedule Trigger node to check daily for overdue tasks:
// Function node to identify overdue suppliers
const schedule = $json.schedule;
const today = new Date();
const overdue = [];
Object.keys(schedule).forEach(supplier => {
const task = schedule[supplier];
if (task && task.status === 'pending' && new Date(task.dueDate) < today) {
overdue.push({
supplier: supplier,
dueDate: task.dueDate,
daysOverdue: Math.floor((today - new Date(task.dueDate)) / (1000 * 60 * 60 * 24))
});
}
});
return { json: { overdue } };
Automated chase-up emails:
Subject: URGENT: {{supplier}} task overdue for {{address}}
This task was due {{daysOverdue}} days ago. Please complete immediately to avoid delaying the sale date.
Property: {{address}}
Sale date: {{saleDate}}
Client: {{clientName}}
Reply to this email with your completion ETA.
Why this approach:
Real estate sales have a critical path where delays cascade. By scheduling suppliers sequentially and tracking deadlines automatically, the system prevents bottlenecks. The daily check catches overdue tasks within 24 hours instead of 3+ days with manual tracking.
Workflow Architecture Overview
This workflow consists of 47 nodes organized into 6 main sections:
- Data ingestion (Nodes 1-8): Webhook capture, address validation, Google Maps integration, form data parsing
- Property valuation (Nodes 9-18): Parallel API calls to CoreLogic, PriceFinder, PropTrack, data aggregation, appraisal generation
- Email verification (Nodes 19-24): Token generation, verification email sending, webhook listener for clicks, database updates
- AI correspondence (Nodes 25-35): Email monitoring, verification check, GPT-4 agent with context retrieval, response sending
- Supplier coordination (Nodes 36-43): Sequential scheduling, deadline calculation, automated emails, status tracking
- Deadline management (Nodes 44-47): Daily schedule trigger, overdue detection, chase-up emails, escalation logic
Execution flow:
- Trigger: Webhook POST from web form submission
- Average run time: 45 seconds for initial appraisal, ongoing for AI monitoring
- Key dependencies: OpenAI API, Australian property data APIs, email service, database
Critical nodes:
- AI Agent (Node 28): Handles all client/buyer correspondence with verification checks
- Function Node (Node 37): Calculates supplier schedule working backwards from sale date
- Schedule Trigger (Node 44): Daily deadline monitoring prevents missed critical path items
The complete n8n workflow JSON template is available at the bottom of this article.
Critical Configuration Settings
OpenAI Integration
Required fields:
- API Key: Your OpenAI API key with GPT-4 access
- Model:
gpt-4-turbo-preview(required for 128k context window) - Temperature: 0.7 (balances creativity with consistency)
- Max tokens: 1000 (sufficient for detailed real estate responses)
Common issues:
- Using GPT-3.5 → Insufficient context handling for complex property queries
- Temperature above 0.9 → Inconsistent responses that confuse clients
- Missing system prompt → AI discusses sensitive info with unverified emails
Australian Property APIs
CoreLogic configuration:
{
"authentication": "headerAuth",
"headerAuth": {
"name": "Authorization",
"value": "Bearer {{$credentials.coreLogicApiKey}}"
},
"endpoint": "https://api.corelogic.com.au/property/v1/suggest",
"queryParameters": {
"q": "={{$json.address}}",
"maxNumberOfResults": 1
}
}
Variables to customize:
maxNumberOfResults: Set to 5 if you want multiple property matches for ambiguous addressestimeout: Increase to 60 seconds for rural properties with slower API responses
Email Verification Security
Token expiration:
const EXPIRATION_HOURS = 24; // Customize based on your security requirements
const expiresAt = new Date(Date.now() + EXPIRATION_HOURS * 60 * 60 * 1000);
Why this matters:
Shorter expiration (4-6 hours) increases security but may frustrate clients in different time zones. 24 hours balances security with user experience for Australian properties.
Testing & Validation
Test the complete workflow:
- Submit test property through web form with your own email
- Verify appraisal email arrives within 60 seconds
- Click verification link and confirm database updates
- Send test buyer inquiry from unverified email → Should receive "verify email" response
- Send test inquiry from verified email → Should receive detailed property information
- Check supplier scheduling emails arrive at correct intervals
Common issues:
- Webhook not triggering: Check firewall allows inbound connections to your n8n instance
- API rate limits: CoreLogic limits to 100 requests/hour on basic plans - implement caching
- Email deliverability: Use SendGrid or Mailgun instead of Gmail SMTP for production
- AI hallucinations: If GPT-4 invents property details, reduce temperature to 0.5 and improve system prompt specificity
Validation checklist:
| Test | Expected Result | Failure Action |
|---|---|---|
| Property appraisal accuracy | Within 5% of manual valuation | Add fourth API source or increase weighting on most accurate provider |
| Email verification | Token expires after 24 hours | Check database timestamp logic |
| AI response time | Under 3 seconds | Upgrade to GPT-4-turbo or reduce context retrieval |
| Supplier scheduling | Emails sent within 5 minutes of trigger | Check SMTP credentials and rate limits |
Deployment Considerations
Production Deployment Checklist
| Area | Requirement | Why It Matters |
|---|---|---|
| Error Handling | Retry logic with exponential backoff on all API calls | Prevents data loss when CoreLogic/OpenAI APIs have temporary outages |
| Monitoring | Webhook health checks every 5 minutes | Detect failures within 5 minutes vs discovering days later when client complains |
| Database Backups | Hourly snapshots of property and client data | Real estate transactions involve legal documents - data loss creates liability |
| Email Deliverability | SPF, DKIM, DMARC records configured | Prevents appraisals landing in spam - 40% open rate vs 5% |
| API Cost Monitoring | Daily spend alerts for OpenAI usage | GPT-4 costs $0.03/1k tokens - runaway AI conversations can cost hundreds |
| Admin Override | Manual pause button for AI agent per property | Allows human intervention when AI mishandles sensitive negotiations |
Scaling considerations:
- 10-50 properties: Current architecture handles this with no modifications
- 50-200 properties: Add Redis caching layer for property data API responses
- 200+ properties: Migrate from webhook triggers to queue-based system (Bull, RabbitMQ)
Real-World Use Cases
Use Case 1: Boutique Real Estate Agency
- Scale: 20-30 listings per quarter
- Modifications: Replace success fee with fixed commission structure
- Integration: Add Xero accounting API for automated invoice generation
- Result: Reduced admin time from 18 hours/week to 3 hours/week
Use Case 2: Property Developer Pre-Sales
- Scale: 50-100 off-market properties
- Modifications: Remove auction agent scheduling, add buyer qualification workflow
- Integration: Connect to CRM (HubSpot) for lead scoring
- Result: Handled 3x more buyer inquiries without additional staff
Use Case 3: Rural Property Specialist
- Scale: 5-10 high-value listings per year
- Modifications: Extend photography deadline to 5 days (travel time), add drone footage coordination
- Integration: Add LandGate API for zoning and land use data
- Result: Improved appraisal accuracy by 15% with additional data sources
Customizations & Extensions
Alternative Integrations
Instead of CoreLogic:
- Domain API: Best for NSW/VIC properties - requires 3 node changes (HTTP Request URL, authentication method, response parsing)
- RPData: Better historical data - swap out nodes 9-12 with RPData-specific endpoints
- Manual valuation: Use Google Sheets as data source - replace API nodes with Google Sheets lookup
Workflow Extensions
Add automated marketing campaigns:
- Connect Mailchimp API after property goes live
- Send weekly updates to buyer database with new listings
- Nodes needed: +8 (Schedule, HTTP Request, Function for segmentation, Merge)
Implement buyer matching:
- Store buyer preferences (location, price range, property type) in database
- When new listing added, query database for matching buyers
- Auto-send personalized property alerts
- Nodes needed: +12 (Database query, Filter, Loop, Email send)
Scale to handle multiple agents:
- Add agent assignment logic in initial webhook
- Route correspondence to correct agent's email
- Create agent-specific dashboards
- Performance improvement: Handles 5x more listings with same infrastructure
Integration possibilities:
| Add This | To Get This | Complexity |
|---|---|---|
| Slack notifications | Real-time alerts when contracts signed or offers received | Easy (3 nodes) |
| Airtable database | Visual pipeline tracking for all properties | Medium (8 nodes) |
| Stripe payment processing | Automated pre-payment and success fee collection | Medium (10 nodes) |
| Twilio SMS | Send inspection reminders to buyers 24 hours before | Easy (4 nodes) |
| DocuSign API | Electronic contract signing workflow | Hard (15 nodes) |
Get Started Today
Ready to automate your real estate operations?
- Download the template: Scroll to the bottom of this article to copy the n8n workflow JSON
- Import to n8n: Go to Workflows → Import from URL or File, paste the JSON
- Configure your services: Add API credentials for OpenAI, CoreLogic/PriceFinder, email service, and database
- Customize the system prompt: Update the AI agent's instructions with your agency's specific policies and terminology
- Test with a sample property: Use a test address to verify appraisals, emails, and supplier scheduling work correctly
- Deploy to production: Connect your web form, activate the workflow, and monitor the first few properties closely
Need help customizing this workflow for your specific real estate operations? Schedule an intro call with Atherial.