Zillow Message Inbox API | Extract Rental & Buying Conversations

Export your Zillow inbox conversations programmatically - Extract complete message threads from both Rental Hub and Buying inboxes with full authentication support and structured JSON output.

• 🔐 Auto-Login & Manual Cookies
• 💬 Full Conversation History
• 📊 Dual Inbox Support

---

📋 Changelog

2025-11-19 - Rental Conversation Counts

• Conversation statistics - Rental output now includes counts object with unread count, not-replied-to count, and total conversation count
• Automatic fetching - Always enabled for rental inbox mode, no additional configuration needed

2025-11-19 - Auto-Login Feature

• Email/password authentication - Login automatically, no manual cookie extraction
• Persistent cookie storage - Cookies saved and reused across runs until expiration
• Smart fallback - Tries credentials → stored cookies → manual cookies automatically
• Backward compatible - Manual cookies still fully supported

---

💰 Pricing

$35/month - Flat rate, unlimited extractions

• ✅ No per-conversation fees - Extract as many conversations as you need
• ✅ Unlimited runs - Run the actor as often as you want
• ✅ No hidden costs - What you see is what you pay

Compare to alternatives:

• Manual export: Impossible for bulk conversations
• API access: Not available for inbox data
• Manual copying: Hours of work for 60+ conversations

What you get for $35/month:

• Access to both Rental Hub and Buying inboxes
• Optional full conversation history extraction
• Clean, structured JSON output

---

🎯 What It Does

The Zillow Message Inbox Exporter programmatically extracts your Zillow conversations from both Rental Hub inbox (for apartment hunters / landlords / property managers) and Buying inbox (for buyers / agents).

Perfect for:

• 📋 Archiving conversations for legal documentation and record-keeping
• 🏢 CRM integration - Import Zillow conversations into your property management system
• 📊 Analytics - Analyze response times, inquiry patterns, and conversion rates
• ⚖️ Legal protection - Maintain complete communication records for tenant disputes
• 🔄 Multi-account management - Export conversations from multiple Zillow accounts

What makes it unique:

• First and only Actor to support Rental Hub and Buying inboxes
• Optional full conversation history - Not just previews, complete message threads
• Secure cookie-based authentication - No credentials stored, no third-party access

---

✨ Key Features

🔐 Multiple Authentication Methods

Auto-login (Recommended): Email/password authentication with automatic cookie management

• Login once, cookies automatically saved and reused
• No manual cookie extraction needed
• Cookies persist across runs until expiration
• Passwords never stored, only session cookies

Manual cookies (Alternative): Traditional browser export method

• Full backward compatibility
• Uses standard browser cookies (zgsession, loginmemento, etc.)
• Same authentication your browser uses

💬 Dual Inbox Support

Access both Rental Hub and Buying inbox conversations in a single run.

• Rental Hub Inbox - Property managers, landlords, rental applications
• Buying Inbox - Real estate agents, buyers, home purchase inquiries
• Both Mode - Extract from both inboxes simultaneously
• Unified JSON output - Clean, consistent data structure

📜 Full Conversation History

Go beyond conversation previews - extract complete message threads with all historical messages.

• Preview mode (default) - Fast extraction, conversation summaries
• Full history mode - Complete message threads, all participants, timestamps
• Configurable via fetchFullConversations parameter
• Handles pagination automatically for long conversations

🎯 Flexible Extraction Modes

Choose exactly what you need - rental conversations, buying conversations, or both.

• Mode: "rental" - Rental Hub inbox only
• Mode: "buying" - Buying inbox only
• Mode: "both" - Both inboxes in one run
• Separate error handling - partial success supported

📊 Clean, Structured Output

Well-formatted JSON with consistent structure across both inbox types.

• Conversation metadata (ID, property, participants)
• Message content with timestamps
• Sender/recipient information
• Attachment references
• System message filtering

---

🎓 Use Cases

👨‍💼 Property Managers

Archive tenant inquiries and application conversations

Property managers handle hundreds of rental inquiries monthly. Export conversations for:

• CRM integration (import into property management software)
• Response time tracking and team performance metrics
• Legal documentation for tenant disputes
• Backup before Zillow deletes old conversations
• Multi-property conversation management

Example workflow:

1. Run actor daily to extract new conversations
2. Import JSON into Airtable/Google Sheets for tracking
3. Monitor response times and conversion rates
4. Archive conversations for legal compliance

🏠 Landlords

Maintain complete communication records

Individual landlords need conversation records for:

• Legal protection in tenant disputes
• Tracking application progress and tenant screening
• Reference checking communication history
• Tax documentation and expense tracking
• Historical records for future reference

🏘️ Real Estate Professionals

Track buyer conversations and lead management

Real estate agents use buying inbox for:

• Lead tracking and CRM integration
• Client communication history
• Follow-up scheduling and reminders
• Performance analytics and conversion tracking
• Team collaboration and handoff documentation

👥 Renters

Export communication for legal documentation

Renters need conversation exports for:

• Landlord-tenant dispute evidence
• Application timeline documentation
• Proof of communication for legal proceedings
• Moving records and apartment search history
• Reference for future rental applications

💻 Developers & Integrators

Automate inbox workflows and build integrations

Developers can use the API to:

• Build custom CRM integrations
• Create automated response time tracking
• Develop tenant screening automation
• Build analytics dashboards
• Integrate with Slack/Discord/email notifications

---

🚀 Quick Start

Basic Example - Auto-Login (Recommended)

Extract your Rental Hub conversations using email/password:

{
  "email": "your.email@example.com",
  "password": "your-password",
  "mode": "rental"
}

Returns: All rental conversations with preview messages (~60 conversations in 5-10 seconds)

Note: Cookies automatically saved and reused on next run.

Alternative - Manual Cookies

Extract using manual browser cookies:

{
  "cookies": "zgsession=1|abc123; loginmemento=1|xyz789; _px3=...; ZILLOW_SID=1|...; zjs_user_id=...",
  "mode": "rental"
}

Returns: Same as auto-login, but requires cookie extraction

Advanced Example - Both Inboxes with Full History

Extract both rental and buying conversations with complete message threads:

{
  "email": "your.email@example.com",
  "password": "your-password",
  "mode": "both",
  "fetchFullConversations": true
}

Returns: Complete conversation history from both inboxes (~60-120 conversations in 30-60 seconds)

Automation Example - Scheduled Daily Export

Set up daily automated extraction for archival:

1. Create an Apify Task with this Actor
2. Set schedule: Daily at 9 AM
3. Configure webhook to send data to your CRM/database
4. Enable email notifications for failures

{
  "email": "your.email@example.com",
  "password": "your-password",
  "mode": "both",
  "fetchFullConversations": false
}

Note: With auto-login, cookies persist across scheduled runs - no manual updates needed.

---

📝 Input Parameters

Authentication (Choose One Method)

Method 1: Auto-Login (Recommended)

Parameter	Type	Description	Example
email	string	Your Zillow account email	"your.email@example.com"
password	string	Your Zillow account password	"your-password"

Method 2: Manual Cookies (Alternative)

Parameter	Type	Description	Example
cookies	string	Zillow authentication cookies. Supports JSON format and browser cookie string format.	See authentication methods below

Note: Provide either (email + password) OR cookies. Not both.

Required Parameters

Parameter	Type	Description	Example
mode	string	Which inbox(es) to extract: "rental", "buying", or "both"	"both"

Optional Parameters

Parameter	Type	Default	Description
fetchFullConversations	boolean	false	Fetch complete message history for each conversation. Increases runtime but provides full thread data.

---

🔐 Authentication Methods

Method 1: Auto-Login (Recommended)

Simplest method - just provide email and password:

{
  "email": "your.email@example.com",
  "password": "your-password"
}

How it works:

1. Actor logs into Zillow automatically
2. Cookies extracted and saved
3. Cookies reused on subsequent runs
4. Re-login only when cookies expire

Storage locations:

• Local: shared/cookies.json
• Apify: Named KV store "zillow-session-store"

Security:

• Passwords never stored, only session cookies
• Cookies valid for 30-90 days
• Automatic re-authentication when needed

Method 2: Manual Cookies (Alternative)

For users who prefer manual cookie extraction:

Step-by-step:

1. Install "Get cookies.txt LOCALLY" extension (Firefox / Chrome)
2. Open Zillow.com and log in
3. Click extension icon → Select JSON format
4. Copy and paste into Actor's cookies input

Required cookies: zgsession, loginmemento, _px3, ZILLOW_SID, zjs_user_id

Supported formats:

JSON format:

{
  "zgsession": "1|abc123",
  "loginmemento": "1|xyz789",
  "_px3": "...",
  "ZILLOW_SID": "1|...",
  "zjs_user_id": "..."
}

Browser string format:

zgsession=1|abc123; loginmemento=1|xyz789; _px3=...; ZILLOW_SID=1|...; zjs_user_id=...

---

📤 Output Structure

The Actor outputs structured JSON with separate sections for rental and buying inbox data.

⚠️ IMPORTANT: The examples below show simplified structures for readability. The actual output contains 30+ additional fields per conversation including timestamps, contact info, property details, application workflow status, and more. Run the Actor to see the complete structure with all fields.

Output Format

{
  "rental": {
    "conversations": [...],
    "counts": {
      "unreadCount": 0,
      "notRepliedToCount": 0,
      "totalConversationsCount": 2
    },
    "pageConversationCount": 2,
    "hasNextPage": false
  },
  "buying": {
    "conversations": [...]
  },
  "mode": "both",
  "scrapedAt": "2025-11-18T13:49:23.353410"
}

Note:

• Rental inbox includes counts object with conversation statistics (unread, not replied to, total count)
• Buying inbox does NOT include pagination fields or counts - only rental inbox has these fields

Rental Conversation Example

Note: Rental conversations do NOT have a participants array - instead, participant info is in referenceName, referenceEmail, landlordName, etc.

{
  "conversationId": "82983937147872*****",
  "listingAlias": "3a6w2gnhfumr3",
  "address": "600 W 246th St, Bronx, NY 10471",
  "addressDetails": {
    "stateAbbrev": "NY"
  },
  "listingName": "Briar Hill Luxury Apartments",
  "beds": "Studio to 1 bed",
  "pricing": "$2,022+",
  "pricingDisplay": "LEGACY",
  "pricingDetails": {
    "isHasBaseRentAndFees": true,
    "baseRentMin": 4369.0,
    "baseRentMax": 12653.0
  },
  "numBathroomsLow": "1.0",
  "numBathroomsHigh": "1.0",
  "photoUrl": "https://photos.zillowstatic.com/fp/601615a076577c5ca06f83ed2e9d9ffe-rentals_thumb_180_180.webp",
  "landlordName": "Glenwood",
  "landlordPhoneNumber": "212-535-0500",
  "referenceName": "Apify User",
  "referenceEmail": "4z66eede1vdxgi4rwp0d******@convo.zillow.com",
  "referenceRelayEmail": "4z66eede1vdxgi4rwp0d******@convo.zillow.com",
  "inquiryId": "1203375813389*****",
  "referenceId": "120337581338992*****",
  "referenceIdType": "hotpadsInquiryId",
  "isActive": true,
  "hasUnreadMessage": false,
  "mostRecentMessageTimestampMs": 1763453374186,
  "lastReadTimestampMs": 1763457504675,
  "notRepliedTo": false,
  "propertyTypeCode": 1,
  "isMultifamily": true,
  "isApplicationsAllowed": false,
  "isApplicationEnabledByLandlord": false,
  "applicationAlreadySent": false,
  "application": {
    "isApplicationsAllowed": false,
    "isApplicationEnabledByLandlord": false,
    "applicationAlreadySentToRenter": false
  },
  "acceptsReplies": true,
  "isConversationBlockedByZillow": false,
  "status": {
    "isArchived": false,
    "isSpam": false,
    "isScheduled": false,
    "applicationMarkedSent": false,
    "isFavorite": false,
    "isConversationBlockedByZillow": false
  },
  "note": {},
  "conversation": [
    {
      "messageId": "6372957625014*****",
      "senderName": "Apify User",
      "senderEmail": "4z66eede1vdxgi4rwp0d******@convo.zillow.com",
      "senderRelayEmail": "4z66eede1vdxgi4rwp0d******@convo.zillow.com",
      "isMessageOwner": true,
      "message": "I'm interested in your property and would like to move forward. Can you send me an application?",
      "messageDate": "Nov 18, 2025 3:08:06 AM",
      "messageDateMs": 1763453286778,
      "messageType": "listingMessage",
      "conversationId": "82983937147872*****",
      "uiTreatmentType": "lowPriority",
      "attachments": [],
      "hasDeletedAttachments": false
    }
  ]
}

Key field notes:

• listingAlias: Listing ID (NOT listingId)
• address: Property address (NOT listingAddress)
• pricing: Price string (NOT listingPrice)
• hasUnreadMessage: Boolean (NOT unreadCount number)
• mostRecentMessageTimestampMs: Unix timestamp in milliseconds (NOT lastMessageTime ISO string)
• status: Object with multiple booleans (NOT string "active")
• messageDateMs: Unix timestamp (NOT timestamp)
• No participants array - use referenceName, referenceEmail, landlordName instead

Buying Conversation Example

⚠️ CRITICAL: Property data (zpid, address, price, photo) is NOT at conversation level - it's embedded in messages.messageList[].richObjects[]. See example below.

{
  "__typename": "ZIMConversation",
  "conversationId": "13abb962-c3f1-11f0-8930-fe89c3731c35",
  "createDate": "2025-11-17T20:07:43.306201559Z",
  "updateDate": "2025-11-17T20:29:26.873527244Z",
  "isArchived": false,
  "header": {
    "id": "X1--*********"
  },
  "participants": [
    {
      "__typename": "ZIMParticipant",
      "id": "X1--*********",
      "unreadMessageCount": 0,
      "persona": "CONSUMER",
      "participantDetails": {
        "__typename": "User",
        "name": "Apify User",
        "firstName": "Apify",
        "lastName": "User",
        "displayName": "zuser20251104004910262",
        "screenName": "zuser20251104004910262",
        "coreProfileData": {
          "profilePhotoUrl": "https://www.zillowstatic.com/static/images/nophoto_h_i.png"
        }
      }
    },
    {
      "__typename": "ZIMParticipant",
      "id": "X1--*********",
      "unreadMessageCount": 0,
      "persona": "AGENT",
      "participantDetails": {
        "__typename": "PAAgent",
        "name": "Claudia ******",
        "photoUrl": "https://photos.zillowstatic.com/fp/2d701a865a8edbdfda32444a907****-h_l.jpg",
        "email": "claudiacort****@gmail.com",
        "screenName": "claudiacortez****",
        "phone": "(419) 517-4543",
        "businessName": "KELLER WILLIAMS CITYWIDE",
        "profile": {
          "__typename": "AgentProfile",
          "ratingAverage": 0,
          "ratingCount": 0,
          "profileUrl": "https://www.zillow.com/profile/claudiacortez****",
          "officeCity": "Maumee",
          "officeState": "OH"
        }
      }
    }
  ],
  "messages": {
    "cursor": null,
    "maxMessages": 250,
    "messageList": [
      {
        "__typename": "ZIMStandardUserMessage",
        "conversationId": "13abb962-c3f1-11f0-8930-******",
        "createDate": "2025-11-17T20:07:43.432828642Z",
        "messageId": "1990512193122012165ae******",
        "senderId": "X1-*********",
        "text": "I am interested in 1024 6th St, Sandusky, OH 44870.",
        "persona": "CONSUMER",
        "attachments": [],
        "richObjects": [
          {
            "__typename": "PropertyRichObject",
            "type": "PROPERTY",
            "version": 1.0,
            "state": {
              "zpid": 34765492
            },
            "fallback": {
              "__typename": "CardRichObject",
              "type": "CARD",
              "version": 1.0,
              "state": {
                "body": "1024 8th St",
                "imageUrl": "https://photos.zillowstatic.com/fp/4dec1e912c931c99a8c4c17ea429d00c-p_f.jpg",
                "subheading": "",
                "tags": [],
                "title": "202000",
                "url": "https://www.zillow.com/homedetails/1024-5th-St-Sandusky-OH-44870/33778498_zpid"
              }
            }
          }
        ]
      }
    ]
  },
  "preview": {
    "__typename": "ZIMStandardUserMessage",
    "conversationId": "13abb962-c3f1-11f0-8930-******",
    "createDate": "2025-11-17T20:29:26.873527244Z",
    "messageId": "1990517660153660074b3b39*****",
    "richObjects": [],
    "senderId": "X1--*********",
    "text": "Hi ***, this is *******...",
    "persona": null,
    "attachments": []
  }
}

Key field notes:

• participants[].id: Participant ID (NOT userId)
• participants[].persona: Role enum: "CONSUMER", "AGENT", or "ZILLOW" (NOT type)
• participantDetails: Deeply nested - structure varies by __typename (User vs PAAgent vs ZillowMessagingUser)
• messages.messageList[].text: Message content (NOT content)
• messages.messageList[].createDate: ISO timestamp (NOT timestamp)
• updateDate: Last activity (NOT lastActivity)
• Property data is in richObjects:
  • richObjects[0].state.zpid: Property ID (33778498)
  • richObjects[0].fallback.state.body: Address ("1024 5th St")
  • richObjects[0].fallback.state.title: Price ("202000")
  • richObjects[0].fallback.state.imageUrl: Property photo
  • richObjects[0].fallback.state.url: Listing URL

How to Extract Property Data from Buying Conversations

Property information is embedded in message richObjects, not at the conversation level:

# Get property zpid
first_message = conversation["messages"]["messageList"][0]
if first_message.get("richObjects"):
    zpid = first_message["richObjects"][0]["state"]["zpid"]

    # Get property details from fallback card
    fallback = first_message["richObjects"][0]["fallback"]["state"]
    address = fallback["body"]          # "1024 5th St"
    price = fallback["title"]           # "202000"
    photo_url = fallback["imageUrl"]
    listing_url = fallback["url"]

Full Conversation History Mode

When fetchFullConversations: true, each conversation includes complete message threads:

{
  "conversationId": "conv_abc123",
  "conversation": [
    {
      "messageId": "msg_001",
      "message": "First message...",
      "timestamp": "2025-01-01T10:00:00Z"
    },
    {
      "messageId": "msg_002",
      "message": "Second message...",
      "timestamp": "2025-01-01T10:15:00Z"
    },
    // ... all 50+ messages in the thread
    {
      "messageId": "msg_050",
      "message": "Most recent message...",
      "timestamp": "2025-01-15T16:30:00Z"
    }
  ],
  "totalMessages": 50
}

---

🔧 Advanced Usage

Daily Archival Automation

Scenario: Property manager wants daily backups of all tenant conversations

Setup:

1. Create Apify Task with schedule: Daily at 9 AM
2. Use mode: "rental" with fetchFullConversations: false for speed
3. Configure webhook to send JSON to your database/CRM
4. Set up email notifications for failures

Input:

{
  "cookies": "your-cookies-here",
  "mode": "rental",
  "fetchFullConversations": false
}

Automation:

• Schedule: 0 9 * * * (cron format)
• Webhook: POST to https://your-crm.com/api/conversations
• Notification: Email on failure
• Storage: Apify dataset (auto-retention)

CRM Integration Workflow

Scenario: Real estate agency wants to sync buying conversations to Salesforce

Workflow:

1. Run actor every 4 hours
2. Extract buying inbox only
3. Parse JSON output
4. Map conversation fields to Salesforce Lead objects
5. Upload via Salesforce API
6. Track sync status in database

Code example (Python):

from apify_client import ApifyClient
import salesforce_api

client = ApifyClient("your-api-token")

# Run the actor
run = client.actor("clearpath/zillow-message-inbox-api").call(
    run_input={
        "cookies": "your-cookies-here",
        "mode": "buying",
        "fetchFullConversations": True
    }
)

# Get results
dataset_items = client.dataset(run["defaultDatasetId"]).list_items().items

# Sync to Salesforce
for item in dataset_items:
    if item["buying"]:
        for conv in item["buying"]["conversations"]:
            salesforce_api.create_lead({
                "name": conv["participants"][0]["name"],
                "property": conv["propertyAddress"],
                "source": "Zillow Buying Inbox",
                "notes": conv["messages"]["messageList"]
            })

Legal Documentation Export

Scenario: Tenant dispute requires complete conversation history as evidence

Process:

1. Run actor once with mode: "rental" and fetchFullConversations: true
2. Extract specific conversation by conversationId
3. Generate PDF report with timestamps
4. Submit to legal counsel

Input:

{
  "cookies": "your-cookies-here",
  "mode": "rental",
  "fetchFullConversations": true
}

Post-processing:

import json
from datetime import datetime

# Load actor output
with open("conversations.json") as f:
    data = json.load(f)

# Find specific conversation
target_conv = next(
    c for c in data["rental"]["conversations"]
    if c["conversationId"] == "disputed-conversation-id"
)

# Format for legal document
legal_doc = {
    "case_number": "2025-TX-12345",
    "property": target_conv["listingAddress"],
    "parties": target_conv["participants"],
    "messages": [
        {
            "timestamp": msg["timestamp"],
            "sender": msg["senderName"],
            "content": msg["message"]
        }
        for msg in target_conv["conversation"]
    ],
    "exported_date": datetime.now().isoformat()
}

# Generate PDF or submit to legal platform

Response Time Analytics

Scenario: Property management company tracks team response times

Metrics to track:

• Average time to first response
• Average time between messages
• Response rates by team member
• Conversion rate (inquiry → showing)

Analysis:

from datetime import datetime

def analyze_response_times(conversations):
    metrics = []

    for conv in conversations:
        messages = conv["conversation"]

        # Find first tenant message and first landlord response
        tenant_msg = next(m for m in messages if m["type"] == "renter")
        landlord_msg = next(m for m in messages if m["type"] == "landlord")

        # Calculate response time
        tenant_time = datetime.fromisoformat(tenant_msg["timestamp"])
        landlord_time = datetime.fromisoformat(landlord_msg["timestamp"])
        response_time = (landlord_time - tenant_time).total_seconds() / 3600  # hours

        metrics.append({
            "conversation_id": conv["conversationId"],
            "property": conv["listingAddress"],
            "response_time_hours": response_time,
            "responder": landlord_msg["senderName"]
        })

    # Calculate averages
    avg_response_time = sum(m["response_time_hours"] for m in metrics) / len(metrics)

    return {
        "average_response_hours": avg_response_time,
        "fastest_response": min(metrics, key=lambda x: x["response_time_hours"]),
        "slowest_response": max(metrics, key=lambda x: x["response_time_hours"]),
        "all_responses": metrics
    }

Multi-Account Management

Scenario: Real estate team manages conversations across 5 Zillow accounts

Setup:

1. Export cookies for each account
2. Create separate Apify Tasks per account
3. Run all tasks simultaneously
4. Aggregate data in central database
5. Build unified dashboard

Task configuration per account:

{
  "cookies": "account-1-cookies",
  "mode": "both",
  "fetchFullConversations": false
}

Aggregation script:

from apify_client import ApifyClient

client = ApifyClient("your-api-token")

accounts = [
    {"name": "Downtown Office", "task_id": "task_123"},
    {"name": "Suburb Office", "task_id": "task_456"},
    {"name": "Luxury Properties", "task_id": "task_789"}
]

all_conversations = []

for account in accounts:
    run = client.task(account["task_id"]).call()
    data = client.dataset(run["defaultDatasetId"]).list_items().items[0]

    # Tag with account name
    for conv in data.get("rental", {}).get("conversations", []):
        conv["account"] = account["name"]
        all_conversations.append(conv)

# Now you have unified data from all accounts
print(f"Total conversations across all accounts: {len(all_conversations)}")

---

🔗 API Integration

Python Example

from apify_client import ApifyClient

# Initialize the ApifyClient with your API token
client = ApifyClient("your-api-token")

# Prepare Actor input
run_input = {
    "cookies": "zgsession=1|abc; loginmemento=1|xyz; _px3=...; ZILLOW_SID=1|...; zjs_user_id=...",
    "mode": "both",
    "fetchFullConversations": True
}

# Run the Actor and wait for it to finish
run = client.actor("clearpath/zillow-message-inbox-api").call(run_input=run_input)

# Fetch results from the Actor's dataset
dataset_items = client.dataset(run["defaultDatasetId"]).list_items().items

# Process the results
for item in dataset_items:
    rental_convos = item.get("rental", {}).get("conversations", [])
    buying_convos = item.get("buying", {}).get("conversations", [])

    print(f"Rental conversations: {len(rental_convos)}")
    print(f"Buying conversations: {len(buying_convos)}")

    # Access individual conversations
    for conv in rental_convos:
        print(f"Property: {conv['listingAddress']}")
        print(f"Messages: {len(conv['conversation'])}")

JavaScript/Node.js Example

import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your API token
const client = new ApifyClient({
    token: 'your-api-token',
});

// Prepare Actor input
const input = {
    cookies: "zgsession=1|abc; loginmemento=1|xyz; _px3=...; ZILLOW_SID=1|...; zjs_user_id=...",
    mode: "both",
    fetchFullConversations: true
};

// Run the Actor and wait for it to finish
const run = await client.actor("clearpath/zillow-message-inbox-api").call(input);

// Fetch results from the Actor's dataset
const { items } = await client.dataset(run.defaultDatasetId).listItems();

// Process the results
items.forEach((item) => {
    const rentalConvos = item.rental?.conversations || [];
    const buyingConvos = item.buying?.conversations || [];

    console.log(`Rental conversations: ${rentalConvos.length}`);
    console.log(`Buying conversations: ${buyingConvos.length}`);

    // Access individual conversations
    rentalConvos.forEach((conv) => {
        console.log(`Property: ${conv.listingAddress}`);
        console.log(`Messages: ${conv.conversation.length}`);
    });
});

cURL Example

# Run the Actor
curl -X POST "https://api.apify.com/v2/acts/clearpath~zillow-message-inbox-api/runs?token=your-api-token" \
  -H "Content-Type: application/json" \
  -d '{
    "cookies": "zgsession=1|abc; loginmemento=1|xyz; _px3=...; ZILLOW_SID=1|...; zjs_user_id=...",
    "mode": "both",
    "fetchFullConversations": true
  }'

# Get the run status
curl "https://api.apify.com/v2/acts/clearpath~zillow-message-inbox-api/runs/last?token=your-api-token"

# Download the dataset
curl "https://api.apify.com/v2/acts/clearpath~zillow-message-inbox-api/runs/last/dataset/items?token=your-api-token" \
  > conversations.json

---

💾 Data Export

JSON (Default)

The Actor outputs clean JSON that can be directly consumed by most systems:

# Download via Apify API
curl "https://api.apify.com/v2/datasets/{dataset-id}/items" > conversations.json

CSV Conversion

Convert to CSV for spreadsheet analysis:

import json
import csv

# Load JSON data
with open("conversations.json") as f:
    data = json.load(f)

# Flatten to CSV
with open("conversations.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["ConversationID", "Property", "LastMessage", "ParticipantCount", "MessageCount"])

    for conv in data[0]["rental"]["conversations"]:
        writer.writerow([
            conv["conversationId"],
            conv["listingAddress"],
            conv["lastMessageTime"],
            len(conv["participants"]),
            len(conv["conversation"])
        ])

Google Sheets Integration

Import conversations directly to Google Sheets:

import gspread
from oauth2client.service_account import ServiceAccountCredentials

# Authenticate with Google Sheets
scope = ['https://spreadsheets.google.com/feeds']
creds = ServiceAccountCredentials.from_json_keyfile_name('credentials.json', scope)
client = gspread.authorize(creds)

# Open spreadsheet
sheet = client.open("Zillow Conversations").sheet1

# Write data
for conv in conversations:
    sheet.append_row([
        conv["conversationId"],
        conv["listingAddress"],
        conv["lastMessageTime"],
        len(conv["conversation"])
    ])

Database Storage

Store in PostgreSQL for querying and analytics:

import psycopg2
import json

conn = psycopg2.connect(
    host="localhost",
    database="zillow_data",
    user="user",
    password="password"
)

cur = conn.cursor()

# Create table
cur.execute("""
    CREATE TABLE IF NOT EXISTS conversations (
        id SERIAL PRIMARY KEY,
        conversation_id VARCHAR(255),
        property_address TEXT,
        conversation_type VARCHAR(50),
        message_count INTEGER,
        last_message_time TIMESTAMP,
        data JSONB
    )
""")

# Insert conversations
for conv in conversations:
    cur.execute("""
        INSERT INTO conversations
        (conversation_id, property_address, conversation_type, message_count, last_message_time, data)
        VALUES (%s, %s, %s, %s, %s, %s)
    """, (
        conv["conversationId"],
        conv["listingAddress"],
        conv["conversationType"],
        len(conv["conversation"]),
        conv["lastMessageTime"],
        json.dumps(conv)
    ))

conn.commit()

---

⚙️ Automation

Scheduled Runs

Set up automatic extraction on a schedule:

1. Navigate to Apify Console → Tasks
2. Create new Task with this Actor
3. Configure schedule:
   • Daily: 0 9 * * * (9 AM every day)
   • Every 4 hours: 0 */4 * * *
   • Weekly: 0 9 * * 1 (Monday 9 AM)
4. Set retention policy for datasets (e.g., 30 days)

Webhook Integration

Send results to external systems automatically:

{
  "webhookUrl": "https://your-system.com/api/conversations",
  "webhookPayloadTemplate": {
    "rentalCount": "{{rental.conversations.length}}",
    "buyingCount": "{{buying.conversations.length}}",
    "data": "{{data}}"
  }
}

Supported webhook targets:

• Zapier
• Make (Integromat)
• n8n
• Custom API endpoints
• Slack/Discord notifications

API Chaining

Trigger downstream Actors based on results:

// Run inbox extractor
const inboxRun = await client.actor("clearpath/zillow-message-inbox-api").call(input);
const conversations = await client.dataset(inboxRun.defaultDatasetId).listItems();

// Trigger analysis Actor
await client.actor("conversation-analyzer").call({
    conversations: conversations.items[0]
});

// Trigger notification Actor
await client.actor("notification-sender").call({
    newConversations: conversations.items[0].rental.conversations.length
});

Error Notifications

Get alerted when Actor fails:

1. Configure email notifications in Task settings
2. Set up Slack webhook for instant alerts
3. Use monitoring service (e.g., UptimeRobot) to check run status
4. Implement retry logic for transient failures

---

💡 Best Practices

Cookie expiration: Zillow cookies typically expire after 30-90 days of inactivity. If you see authentication errors:

1. Log out and log back into Zillow
2. Export fresh cookies using the browser extension
3. Update Actor input with new cookies
4. Re-run the Actor

---

❓ Frequently Asked Questions

General Questions

Q: Should I use auto-login or manual cookies?

A: Auto-login (email/password) is recommended. It's simpler - no browser extensions needed, cookies automatically saved and reused. Manual cookies are an alternative for users who prefer not to share credentials.

Q: Are my credentials and cookies secure?

A: Yes. Passwords are never stored and the Apify Secret Input is used - only session cookies are saved. Cookies are used only for Zillow API requests during runtime. On Apify platform, cookies stored in secure KV store.

Q: How long do auto-login cookies last?

A: Cookies typically valid for 30-90 days. Actor automatically re-authenticates when cookies expire.

Q: How do I get manual cookies (alternative method)?

A: Use "Get cookies.txt LOCALLY" browser extension (Firefox / Chrome). Visit Zillow.com while logged in, click extension icon, select JSON format, copy output. See "Authentication Methods" section for details.

Q: What's the difference between Rental Hub Inbox and Buying Inbox?

A:

• Rental Hub Inbox: For landlords and property managers. Contains conversations about rental properties, lease applications, and tenant inquiries.
• Buying Inbox: For home buyers and real estate agents. Contains conversations about properties for sale, showing requests, and purchase offers.

You can extract from either or both in a single run.

Q: How much does it cost per conversation?

A: There are no per-conversation fees. You pay a flat $35/month and can extract unlimited conversations. Run the Actor as many times as you want with no additional charges.

Q: Can I extract conversations from multiple Zillow accounts?

A: Yes! Run the Actor multiple times with different cookies (one set per account). You can also create separate Apify Tasks for each account and run them simultaneously.

Technical Questions

Q: Why use fetchFullConversations?

A: By default, the Actor returns conversation previews (last 1-3 messages). Enable fetchFullConversations to get complete message history. This is useful for:

• Legal documentation (need full thread)
• Response time analytics (need all timestamps)
• CRM import (need complete context)
• Archival (need historical record)

Trade-off: Increases runtime from ~10 seconds to ~60 seconds for 60 conversations.

Q: How long do Zillow cookies last?

A: Zillow cookies typically expire after 30-90 days of inactivity. If you see authentication errors, log out and log back into Zillow, then export fresh cookies.

Q: What happens if my cookies expire during a run?

A: The Actor will fail with an authentication error. You'll receive an error message indicating invalid cookies. Simply export fresh cookies and re-run the Actor.

Q: Can I filter conversations by date or property?

A: Currently, the Actor extracts all available conversations (typically last 60 per inbox). Post-processing filtering is recommended:

# Filter by date
recent = [c for c in conversations if c["lastMessageTime"] > "2025-01-01"]

# Filter by property
property_convs = [c for c in conversations if "Main St" in c["listingAddress"]]

Q: How many conversations can I extract?

A: The Actor fetches all available conversations from your inbox, typically:

• Rental Hub: ~60 conversations
• Buying Inbox: ~60 conversations
• Total: ~120 conversations in "both" mode

Zillow automatically archives older conversations, so you'll get the most recent active threads.

Q: Does the Actor delete or modify my conversations?

A: No. The Actor only reads data - it never modifies, deletes, or sends messages. Your Zillow inbox remains unchanged.

Q: Can I use this Actor without an Apify account?

A: No, you need an Apify account to run this Actor. However, Apify offers a free tier with $5/month in free usage credits, which is enough to test the Actor before subscribing.

Troubleshooting

Q: I'm getting "Invalid cookies" error. What should I do?

A: This means your cookies are expired or incorrect. Solutions:

1. Log out and log back into Zillow.com
2. Export fresh cookies using the browser extension
3. Verify you have ALL 5 required cookies:
   • ✅ zgsession - Session identifier
   • ✅ loginmemento - Authentication token
   • ✅ _px3 - Security validation
   • ✅ ZILLOW_SID - Session ID
   • ✅ zjs_user_id - User identifier
4. Check cookie format - Should be valid JSON or semicolon-separated string
5. Try a different browser - Firefox vs Chrome sometimes export differently
6. Verify you're logged into the correct Zillow account

Q: The Actor is running but returning 0 conversations. Why?

A: Possible reasons:

1. Your inbox is actually empty (no active conversations)
2. Cookies are for a different Zillow account (verify you're logged into correct account)
3. Cookie format is incorrect (verify JSON syntax)

Q: How do I know if fetchFullConversations is working?

A: Check the conversation array length in the output:

• Preview mode: conversation.length = 1-3 (last few messages)
• Full history mode: conversation.length = 10-100+ (all messages)

If you still see 1-3 messages with fetchFullConversations: true, the conversation might only have 1-3 total messages.

Legal & Compliance

Billing & Subscription

Q: What's included in the $35/month subscription?

A: Everything:

• Unlimited Actor runs
• Unlimited conversations extracted
• Both rental and buying inbox access
• Full conversation history feature
• Residential proxies included
• Email support
• All future updates and bug fixes

Q: Are there any hidden fees?

A: No hidden fees. $35/month is the total cost. However, Apify charges separately for:

• Platform usage (compute/storage) - typically $0.50-2/month for this Actor
• Dataset storage beyond retention policy
• API calls if using Apify API

Total monthly cost: ~$36-38/month.

Q: Can I cancel anytime?

A: Yes, you can cancel your subscription at any time. You'll retain access until the end of your billing period.

Q: Is there a free trial?

A: Apify offers $5 in free monthly credits, which is enough to test the Actor before subscribing.

---

🚀 Getting Started

Ready to export your Zillow conversations? Get started in 3 simple steps:

Step 1: Choose Authentication Method

Option A: Auto-Login (Recommended)

• Just need your Zillow email and password
• No browser extensions required
• Cookies automatically managed

Option B: Manual Cookies (Alternative)

• Install "Get cookies.txt LOCALLY" extension (Firefox / Chrome)
• Visit Zillow.com while logged in
• Export cookies in JSON format

Step 2: Configure and Run

1. Open Actor input configuration
2. Auto-login: Enter email + password OR Manual: Paste cookies
3. Select mode: "rental", "buying", or "both"
4. (Optional) Enable fetchFullConversations
5. Click "Start"

Step 3: Download Data

1. Navigate to "Storage" → "Dataset" tab
2. Click "Export" → Choose format (JSON, CSV, etc.)
3. Download conversation data
4. Import into your CRM/database/spreadsheet

Need help? Contact support at max@mapa.slmail.me

---

📧 Support

• Email: max@mapa.slmail.me
• Feature Requests: Email or submit via issues
• Response Time: Typically within 24 hours

---

⚖️ Legal Compliance

This actor extracts publicly available property listing data. Users are responsible for complying with applicable data protection regulations (GDPR in the EU, CCPA in the US).

Responsible Use: This tool is intended for legitimate real estate research, market analysis, and investment purposes. Do not use scraped data for spam, harassment, or any activities that violate privacy laws.

---

🚀 Start Extracting and Monitoring your Zillow Inbox Now