# My Actor (`fortuitous_pirate/my-actor`) Actor

- **URL**: https://apify.com/fortuitous\_pirate/my-actor.md
- **Developed by:** [Fortuitous Pirate](https://apify.com/fortuitous_pirate) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Airbnb Scraper

Scrape Airbnb listings with comprehensive data including prices, ratings, reviews, availability, and property details. Perfect for market research, price monitoring, and competitive analysis.

### Features

- **Location Search**: Search any city, neighborhood, or region worldwide
- **Direct URL Scraping**: Scrape specific listings by URL
- **Rich Data Extraction**: Prices, ratings, reviews, images, coordinates, and more
- **Flexible Filters**: Filter by price, property type, bedrooms, amenities
- **Date-Based Pricing**: Get accurate prices for specific check-in/check-out dates
- **Guest Configuration**: Specify adults, children, infants, and pets

### Output Data

Each listing includes:

| Field | Description |
|-------|-------------|
| `id` | Airbnb listing ID |
| `name` | Property title |
| `subtitle` | Short description |
| `url` | Direct link to listing |
| `price.total` | Total price for stay |
| `price.perNight` | Nightly rate |
| `price.currency` | Currency code |
| `rating` | Average rating (1-5) |
| `reviewCount` | Number of reviews |
| `bedrooms` | Number of bedrooms |
| `beds` | Number of beds |
| `propertyType` | Type (Apartment, House, etc.) |
| `location.latitude` | GPS latitude |
| `location.longitude` | GPS longitude |
| `images` | Array of image URLs |
| `thumbnailUrl` | Main image URL |
| `badges` | Guest favorite, Superhost, etc. |
| `isGuestFavorite` | Boolean for top-rated listings |
| `searchLocation` | Search location used |
| `scrapedAt` | Timestamp of scrape |

### Example Output

```json
{
  "id": "13998223",
  "name": "Apartment in New York",
  "subtitle": "Cozy Manhattan Studio",
  "url": "https://www.airbnb.com/rooms/13998223",
  "price": {
    "total": 1376,
    "perNight": 275.02,
    "currency": "USD",
    "qualifier": "for 5 nights"
  },
  "rating": 4.92,
  "reviewCount": 193,
  "bedrooms": 1,
  "beds": 1,
  "propertyType": "Apartment",
  "location": {
    "latitude": 40.7589,
    "longitude": -73.9851
  },
  "images": [
    {
      "id": "1378775249",
      "url": "https://a0.muscache.com/im/pictures/...",
      "caption": null
    }
  ],
  "thumbnailUrl": "https://a0.muscache.com/im/pictures/...",
  "badges": [
    {
      "type": "TOP_X_GUEST_FAVORITE",
      "text": "Guest favorite"
    }
  ],
  "isGuestFavorite": true,
  "searchLocation": "New York",
  "scrapedAt": "2026-01-26T18:30:00.000Z"
}
````

### Input Parameters

#### Search Configuration

- **locations**: List of locations to search (e.g., "New York", "Paris, France")
- **listingUrls**: Direct URLs to specific Airbnb listings
- **maxListings**: Maximum listings per location (default: 50, max: 1000)

#### Date Filters

- **checkIn**: Check-in date (YYYY-MM-DD)
- **checkOut**: Check-out date (YYYY-MM-DD)

#### Guest Configuration

- **adults**: Number of adults (default: 1)
- **children**: Number of children (default: 0)
- **infants**: Number of infants (default: 0)
- **pets**: Number of pets (default: 0)

#### Property Filters

- **propertyType**: entire\_home, private\_room, shared\_room, hotel\_room
- **minPrice** / **maxPrice**: Price range per night (USD)
- **minBedrooms**: Minimum number of bedrooms
- **minBeds**: Minimum number of beds
- **minBathrooms**: Minimum number of bathrooms
- **instantBook**: Only instant bookable listings
- **superhost**: Only Superhost listings

#### Advanced Options

- **includeReviews**: Scrape reviews (slower)
- **includeCalendar**: Scrape availability calendar (slower)
- **proxyConfiguration**: Proxy settings (residential recommended)

### Usage Examples

#### Search Multiple Locations

```json
{
  "locations": ["New York", "Los Angeles", "Miami"],
  "maxListings": 100,
  "checkIn": "2026-03-01",
  "checkOut": "2026-03-05"
}
```

#### Filter by Property Type and Price

```json
{
  "locations": ["Paris, France"],
  "propertyType": "entire_home",
  "minPrice": 100,
  "maxPrice": 300,
  "minBedrooms": 2
}
```

#### Scrape Specific Listings

```json
{
  "listingUrls": [
    "https://www.airbnb.com/rooms/12345",
    "https://www.airbnb.com/rooms/67890"
  ]
}
```

### Pricing

This actor uses pay-per-result pricing:

- **$0.005 per listing** scraped

Example costs:

- 100 listings = $0.50
- 1,000 listings = $5.00
- 10,000 listings = $50.00

### Tips for Best Results

1. **Use residential proxies** for highest success rate
2. **Set specific dates** to get accurate pricing
3. **Start with smaller limits** to test your search parameters
4. **Use filters** to narrow down results to relevant listings

### Use Cases

- **Market Research**: Analyze short-term rental markets in any location
- **Price Monitoring**: Track competitor pricing over time
- **Investment Analysis**: Evaluate potential rental income for properties
- **Travel Planning**: Compare options across multiple destinations
- **Competitive Analysis**: Monitor listings in your market area

### Legal Notice

This actor is intended for legitimate market research and data analysis purposes. Users are responsible for ensuring their use complies with Airbnb's Terms of Service and applicable laws.

### Support

For issues or feature requests, please open an issue on the repository or contact support.

# Actor input Schema

## `locations` (type: `array`):

List of locations to search for Airbnb listings (e.g., 'New York', 'Paris, France', 'Tokyo')

## `listingUrls` (type: `array`):

Direct URLs to specific Airbnb listings to scrape (e.g., https://www.airbnb.com/rooms/12345)

## `maxListings` (type: `integer`):

Maximum number of listings to scrape per location. Default is 50.

## `checkIn` (type: `string`):

Check-in date for price search (YYYY-MM-DD format). Leave empty for flexible dates.

## `checkOut` (type: `string`):

Check-out date for price search (YYYY-MM-DD format). Leave empty for flexible dates.

## `adults` (type: `integer`):

Number of adult guests

## `children` (type: `integer`):

Number of children

## `infants` (type: `integer`):

Number of infants

## `pets` (type: `integer`):

Number of pets

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

Filter by property type

## `minPrice` (type: `integer`):

Minimum price per night in USD

## `maxPrice` (type: `integer`):

Maximum price per night in USD

## `minBedrooms` (type: `integer`):

Minimum number of bedrooms

## `minBeds` (type: `integer`):

Minimum number of beds

## `minBathrooms` (type: `integer`):

Minimum number of bathrooms

## `instantBook` (type: `boolean`):

Only show listings with instant booking

## `superhost` (type: `boolean`):

Only show listings from Superhosts

## `includeReviews` (type: `boolean`):

Scrape reviews for each listing (slower, additional charges apply)

## `includeCalendar` (type: `boolean`):

Scrape availability calendar for each listing (slower, additional charges apply)

## `proxyConfiguration` (type: `object`):

Proxy settings for the scraper. Residential proxies recommended for best results.

## Actor input object example

```json
{
  "locations": [
    "New York"
  ],
  "maxListings": 50,
  "adults": 1,
  "children": 0,
  "infants": 0,
  "pets": 0,
  "propertyType": "",
  "instantBook": false,
  "superhost": false,
  "includeReviews": false,
  "includeCalendar": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "locations": [
        "New York"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fortuitous_pirate/my-actor").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 = {
    "locations": ["New York"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("fortuitous_pirate/my-actor").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 '{
  "locations": [
    "New York"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call fortuitous_pirate/my-actor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "My Actor",
        "description": "",
        "version": "0.0",
        "x-build-id": "gHaNaODZzzQ6ZM3Pw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fortuitous_pirate~my-actor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fortuitous_pirate-my-actor",
                "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/fortuitous_pirate~my-actor/runs": {
            "post": {
                "operationId": "runs-sync-fortuitous_pirate-my-actor",
                "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/fortuitous_pirate~my-actor/run-sync": {
            "post": {
                "operationId": "run-sync-fortuitous_pirate-my-actor",
                "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",
                "properties": {
                    "locations": {
                        "title": "Locations to Search",
                        "type": "array",
                        "description": "List of locations to search for Airbnb listings (e.g., 'New York', 'Paris, France', 'Tokyo')",
                        "items": {
                            "type": "string"
                        }
                    },
                    "listingUrls": {
                        "title": "Listing URLs",
                        "type": "array",
                        "description": "Direct URLs to specific Airbnb listings to scrape (e.g., https://www.airbnb.com/rooms/12345)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxListings": {
                        "title": "Max Listings per Location",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape per location. Default is 50.",
                        "default": 50
                    },
                    "checkIn": {
                        "title": "Check-in Date",
                        "type": "string",
                        "description": "Check-in date for price search (YYYY-MM-DD format). Leave empty for flexible dates."
                    },
                    "checkOut": {
                        "title": "Check-out Date",
                        "type": "string",
                        "description": "Check-out date for price search (YYYY-MM-DD format). Leave empty for flexible dates."
                    },
                    "adults": {
                        "title": "Number of Adults",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Number of adult guests",
                        "default": 1
                    },
                    "children": {
                        "title": "Number of Children",
                        "minimum": 0,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Number of children",
                        "default": 0
                    },
                    "infants": {
                        "title": "Number of Infants",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of infants",
                        "default": 0
                    },
                    "pets": {
                        "title": "Number of Pets",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of pets",
                        "default": 0
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "",
                            "entire_home",
                            "private_room",
                            "shared_room",
                            "hotel_room"
                        ],
                        "type": "string",
                        "description": "Filter by property type",
                        "default": ""
                    },
                    "minPrice": {
                        "title": "Minimum Price per Night",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price per night in USD"
                    },
                    "maxPrice": {
                        "title": "Maximum Price per Night",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price per night in USD"
                    },
                    "minBedrooms": {
                        "title": "Minimum Bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Minimum number of bedrooms"
                    },
                    "minBeds": {
                        "title": "Minimum Beds",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Minimum number of beds"
                    },
                    "minBathrooms": {
                        "title": "Minimum Bathrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Minimum number of bathrooms"
                    },
                    "instantBook": {
                        "title": "Instant Book Only",
                        "type": "boolean",
                        "description": "Only show listings with instant booking",
                        "default": false
                    },
                    "superhost": {
                        "title": "Superhost Only",
                        "type": "boolean",
                        "description": "Only show listings from Superhosts",
                        "default": false
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Scrape reviews for each listing (slower, additional charges apply)",
                        "default": false
                    },
                    "includeCalendar": {
                        "title": "Include Availability Calendar",
                        "type": "boolean",
                        "description": "Scrape availability calendar for each listing (slower, additional charges apply)",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the scraper. Residential proxies recommended for best results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
