# Fraser Yachts Scraper — Sale & Charter Listings (`muhammadafzal/fraser-yachts-scraper`) Actor

Scrape Fraser Yachts' public sale and charter listings with yacht specs, prices, photos, capacity, and detail-page enrichment. $0.005 per yacht.

- **URL**: https://apify.com/muhammadafzal/fraser-yachts-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** Travel, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 yacht returneds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Fraser Yachts Scraper

Extract public Fraser Yachts listings for sale and charter into a clean, agent-friendly dataset. It is designed for yacht-market research, inventory monitoring, travel planning, and brokerage workflows that need normalized yacht details rather than screenshots or manually copied web pages.

### When to use it

Use this actor to collect public Fraser listings, compare superyacht specifications, monitor public asking prices, or build a catalogue of sale and charter inventory. It returns one row per yacht and can run against Fraser's sale catalogue, charter catalogue, or a supplied public Fraser catalogue/detail URL.

Do not use it for private or off-market listings, broker contact harvesting, authenticated content, or websites other than `www.fraseryachts.com`.

### Output

Each dataset item contains a stable, flat shape suitable for spreadsheets, APIs, and AI agents:

| Field | Description |
| --- | --- |
| `name` | Public yacht name |
| `listingType` | `sale` or `charter` |
| `listingUrl` | Public Fraser detail-page URL |
| `builder`, `yearBuilt`, `refitYear` | Construction information when available |
| `lengthMeters`, `lengthFeet`, `beamMeters`, `draftMeters` | Public dimensions |
| `price`, `currency` | Sale asking price where available |
| `charterRateWeekly`, `charterRateCurrency` | Charter starting rate where available |
| `guestCapacity`, `cabins`, `crew` | Capacity fields |
| `imageUrl`, `imageUrls`, `description` | Public media and description in detailed mode |

Missing public values are returned as `null`, never guessed.

### Pricing

- Actor start: $0.00005 per run
- Yacht returned: $0.005 per valid public yacht record

`maxResults` is a hard output and per-record billing cap. A run with `maxResults: 25` has a maximum result-event cost of $0.125, plus the start event. Compute and proxy use follow the selected Apify billing option.

### Input examples

#### Sale inventory

```json
{
  "listingType": "sale",
  "maxResults": 25,
  "enrichDetails": true,
  "responseFormat": "detailed"
}
````

#### Charter inventory for an AI workflow

```json
{
  "listingType": "charter",
  "maxResults": 10,
  "responseFormat": "concise"
}
```

#### A specific public Fraser detail page

```json
{
  "startUrls": [{ "url": "https://www.fraseryachts.com/en/yacht-for-sale/christina-o/" }],
  "maxResults": 1
}
```

### MCP use

Use this actor when an agent needs current public Fraser sale or charter inventory with pricing and yacht specifications. Do not use it for general yacht-market coverage or for other broker sites. It returns one structured record per yacht and is charged at $0.005 per yacht returned, plus a $0.00005 start event.

### Reliability and responsible use

The actor uses a session pool, bounded concurrency, retries, schema-safe output writes, and an explicit result cap. Public websites change; when Fraser changes a page layout, the actor preserves successful records and writes warnings in the final run state. Use modest result limits and comply with Fraser's terms and applicable law.

### FAQ

**Does it scrape off-market yachts?** No. It only processes pages publicly accessible on Fraser's website.

**Why is a field null?** Fraser may not publicly show that property for the yacht, or a page layout may omit it.

**Can I pass a Fraser yacht detail URL?** Yes. Add it in `startUrls` and use `maxResults: 1`.

**Are images downloaded?** No. The actor returns public image URLs, avoiding unnecessary storage and transfer costs.

### Legal

This actor is for collecting public information. You are responsible for complying with Fraser Yachts' terms, robots directives, privacy rules, and all applicable laws. Do not use the output to invade privacy, bypass access controls, or create misleading representations of listings.

# Actor input Schema

## `listingType` (type: `string`):

Use this when selecting Fraser Yachts inventory by listing purpose. Choose 'sale', 'charter', or 'both'; for example, choose 'sale' to monitor brokerage inventory. Defaults to 'both' and starts from Fraser's public English catalogues. This is not a private or off-market inventory search.

## `startUrls` (type: `array`):

Use this when you already have Fraser public catalogue or yacht-detail URLs. Enter objects such as {"url":"https://www.fraseryachts.com/en/yachts-for-sale/"}. If empty, the selected listing type determines the catalogue URLs. This does not accept other broker websites or contact-form links.

## `maxResults` (type: `integer`):

Use this when you need a firm output and billing cap. Enter an integer such as 25, with a supported range from 1 to 500. Defaults to 10 and stops charging after that many valid yacht records. This limit applies to returned yachts, not browser requests used to discover them.

## `enrichDetails` (type: `boolean`):

Use this when you want descriptive detail-page fields alongside the core yacht record. For example, enable it for market research that needs longer descriptions and image galleries. Defaults to true; false limits richer textual fields but still opens a yacht page for stable core data. This does not access private broker notes or contact data.

## `responseFormat` (type: `string`):

Use this when an AI agent needs concise records or a data workflow needs images and descriptions. Choose 'concise' for core commercial fields or 'detailed' for up to 20 public image URLs and a description. Defaults to 'detailed'. This does not expose Fraser's unnormalized internal page data.

## Actor input object example

```json
{
  "listingType": "sale",
  "startUrls": [
    {
      "url": "https://www.fraseryachts.com/en/yachts-for-sale/"
    }
  ],
  "maxResults": 25,
  "enrichDetails": true,
  "responseFormat": "concise"
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "listingType": "sale",
    "startUrls": [
        {
            "url": "https://www.fraseryachts.com/en/yachts-for-sale/"
        }
    ],
    "maxResults": 5,
    "enrichDetails": true,
    "responseFormat": "concise"
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/fraser-yachts-scraper").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 = {
    "listingType": "sale",
    "startUrls": [{ "url": "https://www.fraseryachts.com/en/yachts-for-sale/" }],
    "maxResults": 5,
    "enrichDetails": True,
    "responseFormat": "concise",
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/fraser-yachts-scraper").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 '{
  "listingType": "sale",
  "startUrls": [
    {
      "url": "https://www.fraseryachts.com/en/yachts-for-sale/"
    }
  ],
  "maxResults": 5,
  "enrichDetails": true,
  "responseFormat": "concise"
}' |
apify call muhammadafzal/fraser-yachts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fraser Yachts Scraper — Sale & Charter Listings",
        "description": "Scrape Fraser Yachts' public sale and charter listings with yacht specs, prices, photos, capacity, and detail-page enrichment. $0.005 per yacht.",
        "version": "1.0",
        "x-build-id": "MWqwiuNfxcfZeEN23"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/muhammadafzal~fraser-yachts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-muhammadafzal-fraser-yachts-scraper",
                "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/muhammadafzal~fraser-yachts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-muhammadafzal-fraser-yachts-scraper",
                "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/muhammadafzal~fraser-yachts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-muhammadafzal-fraser-yachts-scraper",
                "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": {
                    "listingType": {
                        "title": "Listings to scrape",
                        "enum": [
                            "sale",
                            "charter",
                            "both"
                        ],
                        "type": "string",
                        "description": "Use this when selecting Fraser Yachts inventory by listing purpose. Choose 'sale', 'charter', or 'both'; for example, choose 'sale' to monitor brokerage inventory. Defaults to 'both' and starts from Fraser's public English catalogues. This is not a private or off-market inventory search.",
                        "default": "both"
                    },
                    "startUrls": {
                        "title": "Specific Fraser URLs",
                        "type": "array",
                        "description": "Use this when you already have Fraser public catalogue or yacht-detail URLs. Enter objects such as {\"url\":\"https://www.fraseryachts.com/en/yachts-for-sale/\"}. If empty, the selected listing type determines the catalogue URLs. This does not accept other broker websites or contact-form links.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum yachts",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Use this when you need a firm output and billing cap. Enter an integer such as 25, with a supported range from 1 to 500. Defaults to 10 and stops charging after that many valid yacht records. This limit applies to returned yachts, not browser requests used to discover them.",
                        "default": 10
                    },
                    "enrichDetails": {
                        "title": "Extract detail-page fields",
                        "type": "boolean",
                        "description": "Use this when you want descriptive detail-page fields alongside the core yacht record. For example, enable it for market research that needs longer descriptions and image galleries. Defaults to true; false limits richer textual fields but still opens a yacht page for stable core data. This does not access private broker notes or contact data.",
                        "default": true
                    },
                    "responseFormat": {
                        "title": "Response detail",
                        "enum": [
                            "concise",
                            "detailed"
                        ],
                        "type": "string",
                        "description": "Use this when an AI agent needs concise records or a data workflow needs images and descriptions. Choose 'concise' for core commercial fields or 'detailed' for up to 20 public image URLs and a description. Defaults to 'detailed'. This does not expose Fraser's unnormalized internal page data.",
                        "default": "detailed"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
