# PeoplePerHour Scraper 💰 From $4.5/1K | Jobs & Profiles (`ahmed_jasarevic/peopleperhour-scraper`) Actor

Scrape freelance projects and freelancer profiles from PeoplePerHour: budgets, skills, proposal counts, client details, hourly rates and ratings. Built for agency lead generation, staffing and freelance market research.

- **URL**: https://apify.com/ahmed_jasarevic/peopleperhour-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.40 / 1,000 results

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## PeoplePerHour Scraper

Extract **freelance projects** and **freelancer profiles** from [PeoplePerHour](https://www.peopleperhour.com) as clean, structured JSON — the data you need for **freelance job market research**, **agency lead generation**, **staffing and recruiting**, and **proposal-competition analysis**.

Unlike project-only scrapers, this actor returns **both sides of the marketplace**: open freelance jobs (with budgets, skills, proposal counts and client details) *and* freelancer profiles (with hourly rates, ratings, skills and experience).

### Use Cases

- **Agency & freelancer lead generation** — pull fresh projects matching your skills and pitch them before the proposal count climbs
- **Freelance market research** — track demand by category, budget level, skills and geography over time
- **Recruiting & talent sourcing** — search freelancer profiles by skill to build a candidate pipeline
- **Competitor & rate benchmarking** — see what freelancers in a category charge and how busy projects are
- **Marketplace data pipelines** — feed dashboards, CRMs and Data Warehouses with recurring freelance-market data
- **Building a freelance jobs dataset** — export thousands of projects and profiles for analytics

### How It Works

PeoplePerHour is a React single-page app, but its frontend talks to a **clean internal JSON API that is not behind a Cloudflare/anti-bot wall** and needs no cookies or login. This actor calls that API directly — **no browser, no DOM scraping**, so runs are fast and cheap (256 MB).

1. It resolves your start URLs or search keywords to the correct PeoplePerHour filter (category id or listing tag id).
2. It pages through the JSON API (up to 50 records per request) until `maxItems` is reached.
3. Category slugs that cannot be resolved fall back to a keyword search, so results still match the intent instead of returning the whole unfiltered marketplace.

### Extract Freelance Projects And Freelancer Profiles Without The Official API

PeoplePerHour has **no public developer API** for project or profile data. Third-party "PeoplePerHour APIs" are wrappers around this same public frontend surface. This actor reads that surface directly and returns structured items you can pipe into any tool.

- **Projects** — title, URL, full description, budget + currency + converted budget + budget bracket, project type (fixed / hourly), category & subcategory, skills (category + subcategory), posted & expiry dates, proposal count, location type (remote / on-site), and badges (featured, urgent, high-earning, pre-funded, NDA).
- **Client details** per project — name, country, city, profile URL, job title, member since, verified flag, hourly rate and about text.
- **Freelancers** — name, profile URL, headline, about, skill tags, hourly rate + converted rate + currency, rating & review count, projects completed, completion ratio, response time, buyers worked with, endorsements, last project, location, member since, verified/featured flags, certification, spoken languages and photo.

### Cost & Performance

- Plain HTTP against the internal JSON API — **no browser**, so it is fast and cheap (run at 256 MB).
- The API returns up to 50 records per request; a 100-item run costs roughly 2–4 API calls.
- Free Apify users get a 10-item preview; paid users can pull the full dataset (thousands of profiles, hundreds of open projects).

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `startUrls` | array | No | `/freelance-jobs` + `/hire-freelancers` listings | PeoplePerHour search/category URLs. Supports `/freelance-jobs/...` (projects) and `/hire-freelancers/...` (freelancers), category paths and `?query=` / `?skills=` params. Plain strings or `{ "url": "..." }` objects. |
| `searchQueries` | array | No | `[]` | Keywords to search. Each keyword is searched and filters projects and/or freelancer profiles. |
| `maxItems` | integer | No | `100` | Max records returned (projects + freelancers combined). Free users are capped at 10. |
| `proxy` | object | No | Apify proxy off | Standard Apify proxy picker. |

> **Tip:** the entity type (projects vs freelancers) is driven by the URLs you provide — use `/freelance-jobs/...` URLs to collect projects and `/hire-freelancers/...` URLs to collect freelancer profiles.

### Output

Every dataset item is either a **project** or a **freelancer**. Key fields:

| Field | Type | Description |
|---|---|---|
| `title` | string | Project title or freelancer headline |
| `url` | string | Canonical PeoplePerHour URL |
| `description` | string | Full project description (projects) |
| `budget` / `currency` / `budgetBracket` | number / string | Project budget in native currency |
| `projectType` | string | `fixed_price` or `hourly` |
| `category` / `subCategory` | string | Marketplace category hierarchy |
| `skills` | array | Skill tags |
| `postedDate` / `expiryDate` | string | ISO timestamps (projects) |
| `proposalCount` | number | Bids received (projects) |
| `locationType` | string | `remote` or `on_site` |
| `clientName` / `clientCountry` / `clientUrl` | string | Hiring client details (projects) |
| `hourlyRate` | number | Freelancer hourly rate (freelancers) |
| `rating` / `reviewCount` | number | Freelancer rating and review count |
| `projectsCompleted` | number | Freelancer completed projects |

*(Exact field names are shown in Apify Console's dataset views; the actor output is flattened per entity type.)*

### Example Input

```json
{
    "startUrls": [
        "https://www.peopleperhour.com/freelance-jobs/technology-programming",
        "https://www.peopleperhour.com/hire-freelancers/design"
    ],
    "searchQueries": ["wordpress developer", "logo design"],
    "maxItems": 100,
    "proxy": { "useApifyProxy": false }
}
```

### Example Output

```json
{
    "type": "project",
    "title": "Build a custom WordPress plugin for booking management",
    "url": "https://www.peopleperhour.com/freelance-jobs/technology-programming/wordpress/build-a-custom-wordpress-plugin-4239871",
    "description": "We need an experienced WordPress developer to build a booking plugin with calendar sync...",
    "budget": 800,
    "currency": "GBP",
    "projectType": "fixed_price",
    "category": "Technology & Programming",
    "subCategory": "WordPress",
    "skills": ["WordPress", "PHP", "Plugin Development"],
    "postedDate": "2026-06-18T09:14:22",
    "expiryDate": "2026-07-18T09:14:22",
    "locationType": "remote",
    "proposalCount": 7,
    "clientName": "Sarah M.",
    "clientCountry": "United Kingdom",
    "clientUrl": "https://www.peopleperhour.com/freelancer/sarah-m"
}
```

### Integrations And Automation

- **Apify API** — run the actor programmatically and fetch results from the dataset.
- **Webhooks** — trigger downstream systems when a run finishes.
- **Scheduled runs** — set a **daily** schedule to catch new projects early (proposal counts rise fast; early bidding wins) or a **weekly** schedule for market tracking.
- **Zapier / Make / n8n** — push new projects and profiles into your CRM, Slack or Google Sheets.
- **Export** — download results as JSON, CSV or Excel from the dataset tab.

A recurring daily schedule is the highest-value setup for lead generation: new freelance projects are worth pitching within hours of posting.

### Related Actors

- [Upwork Scraper](https://apify.com/curious_coder/upwork-scraper) — the largest freelance marketplace; pair with this actor to compare freelance demand across platforms
- [Fiverr Scraper](https://apify.com/jungle_synthesizer/fiverr-scraper) — freelance services marketplace data for broader gig-economy research
- [Freelancer.com Scraper](https://apify.com/lexis-solutions/freelancer-scraper) — third major freelance marketplace for triangulating rates and demand
- [Wuzzuf Scraper](https://apify.com/memo23/wuzzuf-scraper) — MENA job-board data if your recruiting research spans regions
- [LinkedIn Jobs Scraper](https://apify.com/curious_coder/linkedin-jobs-scraper) — full-time roles to complement your freelance and contract data

### FAQ

#### Does PeoplePerHour have an official API?

PeoplePerHour has **no public API** for project or profile data. Its seller/marketplace tooling is separate from the public job listings. This actor works with the public listing surface the site's own frontend uses, so you get the same data the website shows — no credentials or approval required.

#### Why use this actor instead of building your own PeoplePerHour scraper?

You don't have to maintain pagination, category-slug resolution, retries or field mappings. The actor already handles category→id mapping, keyword fallbacks for unresolvable slugs, and both URL formats, and returns clean JSON you can schedule and export.

#### What are alternatives to this actor?

Other PeoplePerHour actors on Apify, and managed scraping APIs. This actor is built around the internal JSON API (fast, no browser), and returns both projects **and** freelancer profiles in one run.

#### Can I scrape freelancer profiles, not just projects?

Yes. Point `startUrls` at `/hire-freelancers/...` URLs or use `searchQueries` to collect freelancer profiles with rates, ratings and skills.

#### Does this work for lead generation?

Yes — that is a primary use case. Schedule it daily, filter fresh projects by your category and skills, and export them to your CRM or outreach tool.

#### Can I export the data to CSV or Excel?

Yes. Apify datasets export to JSON, CSV, Excel and more from the dataset tab or via the API.

#### How much does a run cost?

You pay standard Apify platform usage (compute + proxy). A 100-item run is small — a few API calls at 256 MB — so it is inexpensive.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by PeoplePerHour**. It accesses only **publicly available** PeoplePerHour listing and profile pages through the site's own public frontend surface; it does not bypass login, and it does not solve CAPTCHAs.

The output includes **client and freelancer names, locations and profile URLs**. You are responsible for complying with PeoplePerHour's Terms of Service and all applicable data-protection laws (including GDPR where the data relates to individuals in the EU/UK). Do not use personal data collected through this actor for unsolicited commercial outreach in violation of applicable law.

### For AI Agents & LLM Apps

**Purpose:** returns PeoplePerHour freelance projects and/or freelancer profiles as structured JSON items for lead generation, market research and talent sourcing.

**Minimal working input:**

```json
{
    "startUrls": ["https://www.peopleperhour.com/freelance-jobs"],
    "maxItems": 20
}
```

**Variant — keyword search:**

```json
{
    "searchQueries": ["wordpress developer"],
    "maxItems": 50
}
```

**Variant — freelancer profiles:**

```json
{
    "startUrls": ["https://www.peopleperhour.com/hire-freelancers/technology-programming"],
    "maxItems": 50
}
```

**Output fields:** `type`, `title`, `url`, `description`, `budget`, `currency`, `budgetBracket`, `projectType`, `category`, `subCategory`, `skills`, `postedDate`, `expiryDate`, `proposalCount`, `locationType`, `clientName`, `clientCountry`, `clientUrl` (projects); `name`, `url`, `headline`, `skills`, `hourlyRate`, `rating`, `reviewCount`, `projectsCompleted`, `location`, `memberSince`, `verified` (freelancers).

**Behaviors an agent should know:**

- Entity type is driven by the **URL** you pass: `/freelance-jobs/...` → projects, `/hire-freelancers/...` → freelancer profiles.
- `maxItems` caps **projects + freelancers combined**; free Apify accounts are capped at 10 items.
- `startUrls` accepts either plain strings or `{ "url": "..." }` objects.
- Unresolvable category slugs fall back to a keyword search (a warning is logged) rather than returning the whole unfiltered feed.
- Billing is **pay-per-event** (per saved dataset item); see the Store page for live prices.

### SEO Keywords

peopleperhour scraper, peopleperhour api, peopleperhour job scraper, peopleperhour freelancer scraper, scrape peopleperhour projects, freelance job data, freelance project data, freelance marketplace data, freelance lead generation, agency lead generation, freelance jobs dataset, freelance profile scraper, freelance market research, freelance demand data, freelance rate benchmarking, peopleperhour dataset, peopleperhour jobs export, peopleperhour api alternative, upwork jobs api alternative, freelancer jobs api alternative, staffing data, recruiting data, build a freelance jobs database, freelance proposal count data

# Actor input Schema

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

PeoplePerHour search/category URLs to scrape. Supports /freelance-jobs/... (projects) and /hire-freelancers/... (freelancers) URLs, including category paths and ?query= / ?skills= search params.

## `searchQueries` (type: `array`):

Optional keywords to search for. Each keyword is searched against open projects and/or freelancer profiles (depending on entityTypes).

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

Maximum number of records (projects + freelancers combined) to return. Free users are capped at 10.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.peopleperhour.com/freelance-jobs",
    "https://www.peopleperhour.com/hire-freelancers"
  ],
  "searchQueries": [],
  "maxItems": 100,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "startUrls": [
        "https://www.peopleperhour.com/freelance-jobs",
        "https://www.peopleperhour.com/hire-freelancers"
    ],
    "searchQueries": [],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/peopleperhour-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 = {
    "startUrls": [
        "https://www.peopleperhour.com/freelance-jobs",
        "https://www.peopleperhour.com/hire-freelancers",
    ],
    "searchQueries": [],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/peopleperhour-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.peopleperhour.com/freelance-jobs",
    "https://www.peopleperhour.com/hire-freelancers"
  ],
  "searchQueries": [],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/peopleperhour-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/peopleperhour-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/EhItSih3zImaiobzG/builds/wePih0jqYUrpkEjHp/openapi.json