How to give Claude a Singapore property-listings tool with the Apify MCP server

Ask Claude what a four-bedroom condo in Bukit Timah is going for right now and you will get a confident-sounding number that is really a blend of blog posts and forum threads from whenever its training data ended. For a proptech team building comps, an agent qualifying a lead, or an investor screening yield, "roughly right, sometime last year" is worse than useless. Singapore's resale market moves month to month, and price-per-square-foot is the whole game.

In this guide we fix that. We connect Claude to the official Apify MCP server, expose a single Actor that reads live PropertyGuru sale listings, and turn "what is on the market and at what PSF" from a guess into a real query against the current listings. By the end you will have a working property-research tool that Claude, Cursor, or any MCP client can call mid-conversation, and you will know exactly where in the run the tool fires and what it returns.

Everything below is a real setup with real output. No mocked responses.

What is the Apify MCP server?

Model Context Protocol (MCP) is an open standard that lets AI clients call external tools. The Apify MCP server (https://mcp.apify.com) implements that standard on top of the Apify platform, which means every one of the thousands of Actors in the Apify Store becomes a tool an agent can invoke.

Why route an Actor through MCP instead of hard-coding an API call?

• The agent decides when to fetch. Claude reads the conversation, notices it needs a fact it does not have, and calls the tool on its own. You do not write glue code for every question.
• Structured input and output. The MCP server hands Claude the Actor's input schema, so the model fills in the parameters correctly, and returns a clean dataset it can reason over.
• One connection, many tools. The same MCP endpoint exposes search-actors, fetch-actor-details, and call-actor, so an agent can discover and run any Actor without new configuration.
• No infrastructure. The server is hosted. You add a few lines to a config file and you are done.

The Actor we will use

We will expose the Singapore PropertyGuru Listings Scraper. Give it a search query and a listing type (sale or rent) and it returns a structured record for each listing: title, price and price text, price per square foot, property type, bedrooms, bathrooms, floor area, tenure, built year, district and district code, nearest MRT, the listing agent's name, CEA licence number and profile URL, the agency, posting date, and the listing link.

That field set is exactly what property research and lead generation need. Price and PSF drive comparables, beds/baths/area and tenure filter the shortlist, district and MRT distance carry the location premium, and the agent details are the lead. PropertyGuru is Singapore's largest listings portal, so it is a sensible first source for the whole island.

Step 1: Get your Apify API token

Sign in to the Apify Console, open Settings → Integrations, and copy your personal API token. The MCP server uses it to authenticate and to bill Actor runs to your account.

📌 Note: the token is a secret. Keep it in the client config only, never in a prompt or a committed file.

Step 2: Point Claude Desktop at the Apify MCP server

Open Claude Desktop's config file (Settings → Developer → Edit Config, or ~/Library/Application Support/Claude/claude_desktop_config.json on macOS) and add the Apify server. The tools query parameter is the important part: it tells the server which Actor to expose, so Claude gets one focused tool instead of the entire Store.

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=scrapers_lat/singapore-propertyguru-scraper",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}

Cursor uses the same JSON in .cursor/mcp.json. If you prefer to run it locally over stdio instead of the hosted endpoint:

{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--tools", "scrapers_lat/singapore-propertyguru-scraper"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}

Restart Claude Desktop so it picks up the new server.

Step 3: Confirm the tool is loaded

After the restart, the Actor shows up as a callable tool. If you list the tools the Apify server exposes, you will see the storage helpers plus the Actor itself, named after its Store handle:

get-actor-run, get-dataset-items, get-key-value-store-record,
abort-actor-run, scrapers_lat--singapore-propertyguru-scraper

That last entry, scrapers_lat--singapore-propertyguru-scraper, is our property-research tool. Claude now knows it exists, what it does (from the Actor's README), and what inputs it takes (from the input schema the server passes along).

Step 4: Ask Claude to research the market

Now the payoff. In a normal chat, ask a question that requires current listings:

"I'm sizing up 4-bedroom condos for sale around Bukit Timah in Singapore. Pull a few live listings with the price, price per square foot, size, tenure and the listing agent."

Claude recognizes it cannot answer this reliably from memory, selects the PropertyGuru tool, and fills in the input from your question. Under the hood the client sends a tools/call with the Actor's parameters:

{
  "name": "scrapers_lat--singapore-propertyguru-scraper",
  "arguments": {
    "searchQuery": "condo for sale",
    "listingType": "sale",
    "maxListings": 15
  }
}

The Apify MCP server starts the Actor, waits for it to finish, and returns the dataset. Here is the real run metadata it produced:

{
  "runId": "zvIGVc45AyiaFwh60",
  "actorName": "scrapers_lat/singapore-propertyguru-scraper",
  "status": "SUCCEEDED",
  "startedAt": "2026-07-30T17:47:20.756Z",
  "finishedAt": "2026-07-30T17:47:27.534Z",
  "stats": { "runTimeSecs": 6.8 }
}

Under seven seconds, live against the current listings.

Step 5: Read the real output

The dataset the tool returns is structured listing data, one object per property. This is an actual record from the run (trimmed to the fields that matter for research and lead gen):

{
  "title": "High Oak Condo",
  "price": 2000000,
  "priceText": "S$ 2,000,000",
  "psf": "S$ 1,428.57 psf",
  "propertyType": "Condominium",
  "bedrooms": 4,
  "bathrooms": 2,
  "floorArea": 1400,
  "tenure": "99-year Leasehold",
  "builtYear": 2000,
  "district": "Clementi Park / Upper Bukit Timah (D21)",
  "address": "11 Toh Tuck Road",
  "nearestMrt": "9 min (710 m) from DT5 Beauty World MRT Station",
  "agentName": "Alan Sim",
  "agentLicense": "R055965F",
  "agentProfileUrl": "https://www.propertyguru.com.sg/agent/alan-sim-278979",
  "postedDate": "28 Jul 2026",
  "listingUrl": "https://www.propertyguru.com.sg/listing/for-sale-high-oak-condo-60220025"
}

Claude reads that and answers in plain language: High Oak Condo at 11 Toh Tuck Road (District 21) is listed at S$2,000,000, which works out to S$1,428.57 psf for a 1,400 sqft, 4-bedroom, 2-bathroom unit on a 99-year leasehold built in 2000, nine minutes from Beauty World MRT, listed by Alan Sim (CEA licence R055965F) and posted on 28 July 2026. Every one of those facts is traceable to a live listing, not the model's memory.

The PSF field is what makes this useful for research. A raw price tells you almost nothing in Singapore, because a S$2m unit can be a compact new launch or a large older leasehold. Divide by floor area and you can compare across sizes and tenures, which is exactly the number an agent, a buyer, or an investor is actually weighing.

A real use case: a comps-and-leads agent

Put this in context. A property agent preparing for a listing pitch needs, before the meeting, to know:

1. what comparable units in the district are asking,
2. where this listing's PSF sits against them, and
3. which agents and agencies are active on the same stretch.

Without a tool, the agent opens PropertyGuru, runs a search, and copies price, size, and PSF from listing after listing into a spreadsheet, then eyeballs the average. With the tool wired into Claude, the agent asks in plain English for the current sale listings in the district, and Claude calls the Actor, reads the returned set, computes the median and range of PSF, sorts by value, and lists the active agents with their CEA licence numbers. The mechanical copying disappears; the pricing judgment stays with the human.

The same shape works for lead generation. Each record carries the listing agent's name, licence, and profile URL, so a proptech team can build a live map of who is listing what, where, and at what price point, and refresh it on demand instead of scraping by hand.

Going further: chain a second tool

Asking prices are only half the picture. What a comparable unit actually sold for is the other half, and in Singapore that is public data. The same MCP connection can expose more Actors by extending the tools parameter:

https://mcp.apify.com?tools=scrapers_lat/singapore-propertyguru-scraper,scrapers_lat/singapore-hdb-resale-prices-scraper

Now the agent can pull current asking prices from PropertyGuru and the official Singapore HDB Resale Flat Prices Scraper for transacted resale-flat prices in the same conversation, then reason across the two: what is being asked versus what recently closed. Because each Actor is a separate tool, the agent picks the right one for each step on its own and combines the results into one answer.

🏹 Troubleshooting: if the tool does not appear in Claude, the two usual causes are a missing or misspelled Actor handle in the tools parameter (it must be the exact username/actor-name from the Store URL) and a config that was edited while Claude was running. Fix the handle, save, and fully restart the client.

📌 Note: each tool call is a real Actor run billed to your Apify account (this Actor is pay-per-result). Keep maxListings modest for interactive chat, where you want a handful of representative listings, and raise it only when you genuinely need a large pull. For scheduled, high-volume collection, run the Actor directly through the Apify API or a scheduled task rather than one call per chat message.

Wrapping up

You now have an AI agent that can pull live Singapore property listings, on demand, mid-conversation, with the price, PSF, size, tenure, location, and agent detail that real market research and lead gen depend on. The pattern is reusable: pick an Actor that returns fresh structured data, expose it through the Apify MCP server with the tools parameter, and let the agent decide when to call it.

To take it further:

• Switch listingType to rent to research the rental market with the same tool, or change searchQuery to focus on a district or property type.
• Chain the HDB resale Actor, or a mortgage or planning-data Actor, to build a multi-step property-intelligence agent.
• Read the Apify MCP server docs for OAuth setup, resource reads, and the search-actors / call-actor tools that let an agent discover Actors it was not preconfigured with.

The Actor used in this guide: Singapore PropertyGuru Listings Scraper.