# Malt Freelancers Scraper (`crawlerbros/malt-freelancers-scraper`) Actor

Scrape freelancer profiles from Malt, Europe's leading freelancer marketplace. Search by skill/keyword and location, or enrich specific profile URLs. Extracts name, headline, skills, daily rate, rating, experience, location, languages, and more across all Malt markets (FR, DE, ES, BE, NL, COM).

- **URL**: https://apify.com/crawlerbros/malt-freelancers-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Malt Freelancers Scraper

Extract freelancer profiles from [Malt](https://www.malt.com) — Europe's largest freelancer marketplace with 700,000+ verified professionals across France, Germany, Spain, Belgium, Netherlands, and the global platform.

Search by skill or keyword, filter by location and ratings, and enrich specific profile URLs — all in a single actor.

---

### What data you get

Each freelancer record contains:

| Field | Type | Description |
|---|---|---|
| `profileId` | string | Unique Malt profile identifier |
| `name` | string | Full name |
| `profileUrl` | string | Direct link to the freelancer's Malt profile |
| `headline` | string | Professional title or short description |
| `skills` | list[string] | Skills and expertise tags |
| `dailyRateEur` | integer | Daily rate in EUR (if set by the freelancer) |
| `avgRating` | float | Average client rating (0–5) |
| `reviewCount` | integer | Number of client reviews |
| `experienceYears` | integer | Years of professional experience |
| `location` | string | City or region |
| `languages` | list[string] | Spoken languages |
| `verified` | boolean | Whether the freelancer holds a Malt verified badge |
| `market` | string | Malt market scraped (`fr`, `de`, `es`, `be`, `nl`, `com`) |
| `profilePhotoUrl` | string | Profile photo URL |
| `recordType` | string | Always `"freelancer"` |
| `scrapedAt` | string | ISO 8601 UTC timestamp of when the record was scraped |

Fields that are not set by a freelancer are omitted from the output — no null values.

---

### Input parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `mode` | select | Yes | `searchFreelancers` | `searchFreelancers` to search by keyword, or `byProfileUrls` to enrich specific URLs |
| `searchQuery` | string | For search | — | Skill or keyword, e.g. `python developer`, `react`, `ux designer` |
| `location` | string | No | — | City or region filter, e.g. `Paris`, `Berlin` |
| `profileUrls` | list | For byProfileUrls | — | List of Malt profile URLs to enrich |
| `market` | select | No | `com` | Which Malt marketplace to use: `fr`, `de`, `es`, `be`, `nl`, `com` |
| `minRating` | float | No | — | Minimum average rating filter (0–5) |
| `minReviews` | integer | No | — | Minimum review count filter |
| `maxItems` | integer | No | `20` | Maximum number of profiles to return (1–5000) |

---

### Supported markets

| Market code | Domain | Country |
|---|---|---|
| `com` | malt.com | Global / English |
| `fr` | malt.fr | France |
| `de` | malt.de | Germany |
| `es` | malt.es | Spain |
| `be` | malt.be | Belgium |
| `nl` | malt.nl | Netherlands |

---

### Example inputs

#### Search for Python developers in Paris (French market)

```json
{
  "mode": "searchFreelancers",
  "searchQuery": "python developer",
  "location": "Paris",
  "market": "fr",
  "maxItems": 50
}
````

#### Search for React freelancers in Germany with rating filter

```json
{
  "mode": "searchFreelancers",
  "searchQuery": "react developer",
  "market": "de",
  "minRating": 4.5,
  "minReviews": 3,
  "maxItems": 100
}
```

#### Enrich specific freelancer profile URLs

```json
{
  "mode": "byProfileUrls",
  "profileUrls": [
    "https://www.malt.fr/profile/johndoe",
    "https://www.malt.de/profile/jane-smith"
  ]
}
```

#### Global search across all markets

```json
{
  "mode": "searchFreelancers",
  "searchQuery": "data scientist",
  "market": "com",
  "maxItems": 200
}
```

***

### Example output

```json
{
  "profileId": "johndoe",
  "name": "John Doe",
  "profileUrl": "https://www.malt.fr/profile/johndoe",
  "headline": "Senior Python & Data Engineering Freelancer",
  "skills": ["Python", "Django", "FastAPI", "PostgreSQL", "AWS"],
  "dailyRateEur": 650,
  "avgRating": 4.9,
  "reviewCount": 18,
  "experienceYears": 10,
  "location": "Paris",
  "languages": ["French", "English"],
  "verified": true,
  "market": "fr",
  "profilePhotoUrl": "https://cdn.malt.com/photos/johndoe.jpg",
  "recordType": "freelancer",
  "scrapedAt": "2026-05-15T10:30:00+00:00"
}
```

***

### Use cases

- **Talent sourcing** — Find and qualify freelancers by skill, location, and rating
- **Market research** — Analyse daily rates and skill demand across European markets
- **Competitor benchmarking** — Track top-rated freelancers in your niche
- **Lead generation** — Build targeted outreach lists from Malt search results
- **Freelancer directory** — Enrich existing databases with up-to-date Malt profile data

***

### Frequently Asked Questions

**Which Malt markets are supported?**
All six Malt domains: malt.com (global), malt.fr (France), malt.de (Germany), malt.es (Spain), malt.be (Belgium), and malt.nl (Netherlands).

**Does it require login or cookies?**
No. The actor scrapes publicly available profile information only — no account or cookies are needed.

**How many profiles can I scrape?**
Up to 5,000 profiles per run. For larger volumes, run multiple searches with different queries or markets.

**Are daily rates always available?**
Daily rates are set voluntarily by freelancers. When a freelancer has not published their rate, the `dailyRateEur` field is omitted from the record.

**What is the `verified` field?**
Malt awards a verified badge (called "Supermalter" in some markets) to freelancers who meet quality and activity thresholds. The `verified` field reflects this badge status.

**Can I filter by minimum rating or review count?**
Yes — use `minRating` (0–5) and `minReviews` to filter the results. Freelancers without a rating or reviews will still pass the filter (they are not excluded for having no data).

**Can I search by tag or category URL?**
In `searchFreelancers` mode, enter the skill name as the `searchQuery`. Malt's search is skill/keyword based.

**Why does the actor need a European proxy?**
Malt's platform is only accessible from European IP addresses. The actor automatically uses Apify's European datacenter proxy to access the site.

**What output format is supported?**
The dataset can be downloaded in JSON, CSV, Excel, XML, RSS, or HTML format from the Apify platform.

**Is this actor suitable for daily automated runs?**
Yes. The default `prefill` values (`mode=searchFreelancers`, `searchQuery=python developer`, `maxItems=5`) produce at least one record in Apify's daily automated test runs.

# Actor input Schema

## `mode` (type: `string`):

Choose what to scrape: search for freelancers by keyword/location, or enrich specific profile URLs.

## `searchQuery` (type: `string`):

Skill or keyword to search for, e.g. `python developer`, `react`, `data analyst`. Used in mode=searchFreelancers.

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

Filter results by city or region, e.g. `Paris`, `Berlin`, `Barcelona`. Leave empty for all locations.

## `profileUrls` (type: `array`):

List of Malt freelancer profile URLs to enrich, e.g. `https://www.malt.fr/profile/johndoe`. Used in mode=byProfileUrls.

## `market` (type: `string`):

Which Malt regional marketplace to scrape.

## `minRating` (type: `number`):

Only include freelancers with an average client rating at or above this value (0–5). Leave empty to include all.

## `minReviews` (type: `integer`):

Only include freelancers with at least this many client reviews. Leave empty to include all.

## `maxItems` (type: `integer`):

Maximum number of freelancer records to return.

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

Malt blocks non-European IPs. A European proxy is required. Use Apify Residential (DE) for best results. Datacenter EU also works if available on your plan.

## Actor input object example

```json
{
  "mode": "searchFreelancers",
  "searchQuery": "python developer",
  "profileUrls": [],
  "market": "de",
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}
```

# Actor output Schema

## `freelancers` (type: `string`):

Dataset containing all scraped Malt freelancer profiles.

# 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 = {
    "mode": "searchFreelancers",
    "searchQuery": "python developer",
    "profileUrls": [],
    "market": "de",
    "maxItems": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "DE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/malt-freelancers-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 = {
    "mode": "searchFreelancers",
    "searchQuery": "python developer",
    "profileUrls": [],
    "market": "de",
    "maxItems": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "DE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/malt-freelancers-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 '{
  "mode": "searchFreelancers",
  "searchQuery": "python developer",
  "profileUrls": [],
  "market": "de",
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}' |
apify call crawlerbros/malt-freelancers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Malt Freelancers Scraper",
        "description": "Scrape freelancer profiles from Malt, Europe's leading freelancer marketplace. Search by skill/keyword and location, or enrich specific profile URLs. Extracts name, headline, skills, daily rate, rating, experience, location, languages, and more across all Malt markets (FR, DE, ES, BE, NL, COM).",
        "version": "1.0",
        "x-build-id": "NH13oLS1doEVJXBAp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~malt-freelancers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-malt-freelancers-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/crawlerbros~malt-freelancers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-malt-freelancers-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/crawlerbros~malt-freelancers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-malt-freelancers-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchFreelancers",
                            "byProfileUrls"
                        ],
                        "type": "string",
                        "description": "Choose what to scrape: search for freelancers by keyword/location, or enrich specific profile URLs.",
                        "default": "searchFreelancers"
                    },
                    "searchQuery": {
                        "title": "Search query (skill / keyword)",
                        "type": "string",
                        "description": "Skill or keyword to search for, e.g. `python developer`, `react`, `data analyst`. Used in mode=searchFreelancers."
                    },
                    "location": {
                        "title": "Location (city or region)",
                        "type": "string",
                        "description": "Filter results by city or region, e.g. `Paris`, `Berlin`, `Barcelona`. Leave empty for all locations."
                    },
                    "profileUrls": {
                        "title": "Profile URLs (mode=byProfileUrls)",
                        "type": "array",
                        "description": "List of Malt freelancer profile URLs to enrich, e.g. `https://www.malt.fr/profile/johndoe`. Used in mode=byProfileUrls.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "market": {
                        "title": "Market (Malt domain)",
                        "enum": [
                            "com",
                            "fr",
                            "de",
                            "es",
                            "be",
                            "nl"
                        ],
                        "type": "string",
                        "description": "Which Malt regional marketplace to scrape.",
                        "default": "de"
                    },
                    "minRating": {
                        "title": "Minimum average rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only include freelancers with an average client rating at or above this value (0–5). Leave empty to include all."
                    },
                    "minReviews": {
                        "title": "Minimum number of reviews",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Only include freelancers with at least this many client reviews. Leave empty to include all."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of freelancer records to return.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Malt blocks non-European IPs. A European proxy is required. Use Apify Residential (DE) for best results. Datacenter EU also works if available on your plan."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
