# STR Scout 🏠 Airbnb Market Intel + Arbitrage Score | MCP (`ramosss/str-scout`) Actor

Score any property address (0-100) for Airbnb arbitrage viability. Plus: full market analysis (revenue, ADR, occupancy, saturation, comps) and local STR regulations lookup. MCP-ready for Claude/Cursor. Pay-per-query — the AirDNA alternative for STR investors & AI agents.

- **URL**: https://apify.com/ramosss/str-scout.md
- **Developed by:** [Arthur ramos](https://apify.com/ramosss) (community)
- **Categories:** Real estate, Agents, Lead generation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1,000.00 / 1,000 arbitrage score calls

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## STR Scout — Short-Term Rental Market Intelligence

> ⚠️ **Unofficial.** This Actor is not affiliated with, endorsed by, or sponsored by Airbnb, Inc., or any other third-party platform. All trademarks belong to their respective owners.

Short-term rental market intelligence with **4 tools** accessible via **MCP**, **REST**, or batch run. Built for STR investors, hosts, property managers, and AI agents that need market data on demand.

### What you get

- **Search comparable listings** by city with bedroom/price/property-type filters
- **Local regulation lookup** — permitted, restricted, banned, or capped, plus license requirements and night caps
- **Full market analysis** — revenue estimates, ADR percentiles, occupancy, saturation scoring, amenity gaps, comparables, and AI investment summary
- **Arbitrage score** for a specific address (0-100) with regulation-aware viability recommendation, projected net income, and break-even occupancy

### Disclaimer

> **This is an unofficial tool.** STR Scout aggregates publicly available data and analytical estimates. Output is informational only and does not constitute investment, legal, or tax advice. Regulatory data may be out of date — verify with the local jurisdiction before transacting. STR Scout is not affiliated with, endorsed by, or sponsored by Airbnb, Inc., or any third-party platform. All names, logos, and trademarks referenced are the property of their respective owners.

### Tools and pricing

| Tool | Price per call | Use case |
|---|---|---|
| `search-listings` | $0.05 | Discover comparable listings in a city |
| `regulations` | $0.10 | Check whether a city allows STR (kills bad deals fast) |
| `market-analysis` | $0.50 | Full market report — revenue, ADR, occupancy, saturation, AI summary |
| `arbitrage-score` | $1.00 | Score a property address (0-100) for STR viability |

Pricing is **pay-per-event**. You are only charged when a tool successfully starts; failed validations and platform errors are not billed at the tool rate.

### Use from an MCP client (Claude Desktop, Cursor, Cline, etc.)

```json
{
  "mcpServers": {
    "str-scout": {
      "url": "https://<your-actor-standby-url>/mcp",
      "headers": { "Authorization": "Bearer <your-apify-token>" }
    }
  }
}
````

Once connected, the four tools appear in your client's tool palette. Use them like:

> "Use str-scout to look up the regulations for Austin, then run a market analysis for 2-bedroom entire homes there."

### Use from REST / curl

```bash
curl -X POST https://<your-actor-standby-url>/market-analysis \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"location":"Austin, TX","bedrooms":2}'
```

Discover the available tool surface at `GET /tools` and the OpenAPI spec at `GET /openapi.json`.

### Use as a one-shot Apify run (batch mode)

Click **Start** with the default input, or override `location`, `propertyType`, `bedrooms`. The market analysis is pushed to the run's default dataset.

```json
{ "location": "Lisbon", "propertyType": "entire_home", "bedrooms": 2 }
```

### Output (market-analysis example)

```json
{
  "location": "Lisbon",
  "dataFreshness": "cached_48h",
  "totalListingsAnalyzed": 1247,
  "filteredListings": 421,
  "revenueEstimate": { "lowEstimate": 28400, "midEstimate": 41200, "highEstimate": 56800, "confidenceLevel": "high" },
  "averageDailyRate": { "median": 142, "percentile25": 98, "percentile75": 198 },
  "occupancyEstimate": { "estimatedRate": 0.72, "confidenceLevel": "high" },
  "competitiveSaturation": { "score": 62, "label": "competitive", "totalListings": 1247 },
  "topComparables": [ "..." ],
  "investmentSummary": "Lisbon shows competitive but profitable conditions..."
}
```

### Output (arbitrage-score example)

```json
{
  "address": "Rua de São Bento 100, Lisbon",
  "city": "Lisbon",
  "score": {
    "total": 64,
    "subscores": { "regulation": 60, "demand": 72, "profitability": 58, "saturation": 38 },
    "projectedAnnualRevenue": 36800,
    "projectedNetIncome": 12400,
    "breakEvenOccupancy": 0.51,
    "recommendation": "marginal",
    "warnings": ["Lisbon AL containment zones suspend new licenses in central districts."]
  },
  "narrative": "Score 64/100 (marginal). Lisbon's AL framework allows operation outside containment zones..."
}
```

### Coverage

- **Open-data feeds** — ~30 metros across North America, Europe, and Asia-Pacific (Austin, NYC, LA, SF, Boston, Chicago, Lisbon, Porto, Barcelona, Madrid, Paris, London, Berlin, Amsterdam, Rome, Milan, Athens, Sydney, Melbourne, Mexico City, Buenos Aires, Rio, Vienna, Copenhagen, Edinburgh, Asheville, Denver, San Diego, Seattle, Nashville, and more)
- **Live market scrape fallback** — any other city, slower cold start (5-30s on first request)
- **Regulatory data** — 10 cities in v1 (NYC, SF, LA, Austin, Nashville, Miami Beach, Lisbon, Barcelona, Paris, London); other cities return `unknown`

### Limits and known issues

- Amenity-gap analysis is reduced for cities served by open-data feeds (the open feed doesn't carry amenity arrays)
- First request to a new city has 5-30s cold start while data loads; subsequent requests are sub-second
- Regulations data is hand-curated and refreshed quarterly — always verify with local jurisdiction before transacting
- ADR/occupancy estimates use a review-velocity model with assumed 60% review rate and 3.5-night average stay; actual performance varies

### Support

Issues, feature requests, or city additions: contact via Apify Console messaging.

# Actor input Schema

## `location` (type: `string`):

City to analyze. Best results for major metros covered by curated open-data feeds; other cities use a live market scrape (slower).

## `propertyType` (type: `string`):

Type of property to analyze.

## `bedrooms` (type: `integer`):

Filter to listings with at least this many bedrooms. Leave empty for all.

## Actor input object example

```json
{
  "location": "Lisbon",
  "propertyType": "entire_home",
  "bedrooms": 2
}
```

# Actor output Schema

## `dataset` (type: `string`):

Each batch run pushes one MarketAnalysis record.

## `keyValueStore` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "location": "Lisbon",
    "propertyType": "entire_home",
    "bedrooms": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("ramosss/str-scout").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "location": "Lisbon",
    "propertyType": "entire_home",
    "bedrooms": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("ramosss/str-scout").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "location": "Lisbon",
  "propertyType": "entire_home",
  "bedrooms": 2
}' |
apify call ramosss/str-scout --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ramosss/str-scout",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "STR Scout 🏠 Airbnb Market Intel + Arbitrage Score | MCP",
        "description": "Score any property address (0-100) for Airbnb arbitrage viability. Plus: full market analysis (revenue, ADR, occupancy, saturation, comps) and local STR regulations lookup. MCP-ready for Claude/Cursor. Pay-per-query — the AirDNA alternative for STR investors & AI agents.",
        "version": "0.1",
        "x-build-id": "KUbCzvXcNeOvqBVdf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ramosss~str-scout/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ramosss-str-scout",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/ramosss~str-scout/runs": {
            "post": {
                "operationId": "runs-sync-ramosss-str-scout",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/ramosss~str-scout/run-sync": {
            "post": {
                "operationId": "run-sync-ramosss-str-scout",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "location"
                ],
                "properties": {
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City to analyze. Best results for major metros covered by curated open-data feeds; other cities use a live market scrape (slower).",
                        "default": "Lisbon"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "entire_home",
                            "private_room",
                            "any"
                        ],
                        "type": "string",
                        "description": "Type of property to analyze.",
                        "default": "entire_home"
                    },
                    "bedrooms": {
                        "title": "Bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Filter to listings with at least this many bedrooms. Leave empty for all.",
                        "default": 2
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```