# Freelancer.com Scraper (`solidcode/freelancer-com-scraper`) Actor

\[💰 $0.95 / 1K] Extract active project listings from Freelancer.com — titles, descriptions, skills, budgets, bid counts, and employer flags. Filter by keyword, category, fixed vs hourly, budget range, country, and sort order. Built for lead generation, market research, and pricing intelligence.

- **URL**: https://apify.com/solidcode/freelancer-com-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Lead generation, Jobs, Automation
- **Features:** Limited permissions
- **Stats:** 71 total users, 11 monthly users, 99.8% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.95 / 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

## Freelancer.com Scraper

Pull active project listings from Freelancer.com at scale — titles, full descriptions, skills tags, fixed and hourly budgets, bid counts and average bid amounts, employer country, posted and bid-close dates, and seven quality badges including Featured, Urgent, Sealed, NDA-required, Recruiter-assisted and Preferred-Freelancer-only. Built for sales teams, agencies, and market-research analysts who need fresh freelance-marketplace demand signal without building and maintaining their own data pipeline.

### Why This Scraper?

- **16 top-level Freelancer categories** — Websites/IT/Software, Mobile & Computing, Writing & Content, Design Media & Architecture, Engineering & Science, Sales & Marketing, Translation, Trades & Services, and 8 more — selectable from a single dropdown.
- **7 project-quality badges per row** — Featured, Urgent, Sealed, NDA-required, Recruiter-assisted, Preferred-Freelancer-only and IP-agreement — surface high-intent posts at a glance. Recruiter-assisted fires on roughly 1 in 8 active projects, and Preferred-Freelancer-only on 1 in 14, so they are working filters rather than rare curiosities.
- **50-country employer filter, matched on the client's own country** — not on the currency they pay in, so a Malaysian client paying in US dollars is found under Malaysia. Pinpoint clients in the US, UK, Canada, Australia, India, UAE, Germany, Singapore, Brazil and 41 more, with a 2-letter ISO `country` on every row of a country-filtered run.
- **Every budget priced twice, natively and in dollars** — `budgetMin` / `budgetMax` in the project's own currency, `budgetMinUsd` / `budgetMaxUsd` on the same row in USD, plus the ISO `currency` code. Roughly half of all active projects are posted outside the dollar, so this is the difference between a rate benchmark and a number that mixes rupees with pounds.
- **Live bid intelligence, comparable across all 9 currencies Freelancer prices in** — USD, EUR, GBP, INR, AUD, CAD, SGD, NZD and HKD. Every row carries `bidCount`, `bidAvg` in the project's own currency, and `bidAvgUsd` converted to dollars, so you can average going rates across a mixed result set instead of hand-converting each row.
- **Posted and closing timestamps** — `submitDate` and `bidEndDate` ISO 8601, plus a human-readable `timeLeft` string like "3 days left" or "Closes today".
- **Direct URL pasting** — drop any Freelancer.com URL (`/jobs/<skill>`, `/jobs/<skill>/<page>`, `/search/projects?q=...`) into the input and it's parsed into the right filters automatically.
- **Four sort orders** — Relevance, Newest first, Lowest budget first, Highest budget first.
- **Up to 10,000 results per run, spread across searches** — any one search term or URL returns about 5,000 projects at most, so stacking two or more searches is what fills a full 10,000-row snapshot in a single pass.

### Use Cases

**Lead Generation**

- Build outreach lists of clients posting projects matching your service area
- Filter by minimum budget to target premium clients with real spend
- Capture employer country to prioritize same-timezone leads
- Identify Featured and Urgent posts where clients want to move fast

**Market Research & Demand Tracking**

- Track freelance demand by skill, region, and budget range over time
- Compare project volume across the 16 Freelancer categories
- Measure average budgets per skill to benchmark market rates
- Spot rising and declining technology demand week over week

**Competitive Intelligence**

- See exactly which projects competing agencies are bidding on
- Monitor average bid counts to gauge how saturated a niche is
- Track which client countries dominate a given skill category
- Watch a competitor's preferred client patterns by mirroring their search filters

**Pricing & Rate Benchmarking**

- Compute average fixed-price and hourly budgets per skill
- Compare US-employer budgets against India, Philippines, or UK budgets
- Build internal rate cards anchored to live marketplace data
- Detect when premium-budget projects appear in your niche

**Recruiting & Sourcing**

- Find clients who post recurring work in a specific skill area
- Identify long-bid-window projects ideal for thoughtful proposals
- Track NDA-flagged, Sealed and IP-agreement projects for high-trust opportunities
- Chase Recruiter-assisted and Preferred-Freelancer-only posts, where the client has already paid to narrow the field

### Getting Started

#### Search by Keyword

The simplest way to start:

```json
{
    "searchQueries": ["shopify"],
    "maxResults": 100
}
```

#### Filter by Category and Budget

```json
{
    "searchQueries": ["react native"],
    "category": "websites-it-software",
    "projectType": "fixed",
    "minBudget": 500,
    "maxBudget": 5000,
    "sortBy": "newest",
    "maxResults": 200
}
```

#### Target Premium US Clients

```json
{
    "searchQueries": ["seo", "content marketing"],
    "country": "us",
    "minBudget": 1000,
    "sortBy": "budget_high",
    "maxResults": 500
}
```

#### Paste Freelancer.com URLs Directly

```json
{
    "searchUrls": [
        "https://www.freelancer.com/jobs/web-development",
        "https://www.freelancer.com/job-search/?q=wordpress&fixed_min=500&fixed_max=3000"
    ],
    "maxResults": 300
}
```

### Input Reference

#### Search Inputs

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | array of strings | `["seo"]` | Free-text keywords. Each query produces its own result set. |
| `searchUrls` | array of strings | `[]` | Paste Freelancer.com category, search, or project URLs. Filters in the URL are honored. |

#### Filters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `category` | string | none | One of 16 Freelancer categories (e.g. `websites-it-software`, `design-media-architecture`, `writing-content`). |
| `projectType` | string | `all` | `all`, `fixed`, or `hourly`. |
| `minBudget` | integer | none | Keep only projects whose posted budget starts at or above this amount. Other currencies are converted to USD first. |
| `maxBudget` | integer | none | Keep only projects whose posted budget tops out at or below this amount. Open-ended budgets are excluded. |
| `country` | string | none | 2-letter employer country code (e.g. `us`, `gb`, `de`). Matches the client's own country, not the currency they pay in. 50 countries supported. |

#### Sort & Limits

| Parameter | Type | Default | Description |
|---|---|---|---|
| `sortBy` | string | `relevance` | `relevance`, `newest`, `budget_low`, or `budget_high`. |
| `maxResults` | integer | `1000` | Total row cap across all queries and URLs. Maximum 10,000. Set to `0` to request the full 10,000-row maximum. Any one search term or URL returns about 5,000 projects at most, so 10,000 in one run needs two or more searches. |

### Output

#### Example Row

```json
{
    "projectId": 38492013,
    "projectName": "Shopify Plus migration with custom theme",
    "projectDescription": "We are migrating from BigCommerce to Shopify Plus...",
    "projectDescriptionHtml": "We are migrating from BigCommerce to Shopify Plus...<br><br>Requirements:...",
    "url": "https://www.freelancer.com/projects/shopify-plus-migration-custom-theme",
    "seoUrl": "shopify-plus-migration-custom-theme",
    "jobType": "fixed",
    "currency": "USD",
    "budgetMin": 1500,
    "budgetMax": 4500,
    "budgetMinUsd": 1500,
    "budgetMaxUsd": 4500,
    "budgetDisplay": "$1,500 - $4,500 USD",
    "bidCount": 27,
    "bidAvg": 2890.5,
    "bidAvgUsd": 2890.5,
    "timeLeft": "5 days left",
    "submitDate": "2026-05-06T14:22:01Z",
    "bidEndDate": "2026-05-13T14:22:01Z",
    "country": "us",
    "location": "Hayward, California, United States",
    "skills": ["Shopify", "Liquid", "JavaScript", "BigCommerce"],
    "featured": true,
    "urgent": false,
    "sealed": false,
    "nda": false,
    "recruiterAssisted": true,
    "preferredFreelancerOnly": false,
    "ipAgreement": false,
    "language": "en",
    "scrapedAt": "2026-05-08T10:31:42Z"
}
```

#### Core Fields

| Field | Type | Description |
|---|---|---|
| `projectId` | integer | Numeric Freelancer project ID. |
| `projectName` | string | Project title. |
| `projectDescription` | string | Full plaintext description with line breaks. |
| `projectDescriptionHtml` | string | Same description with `<br>` tags for HTML rendering. |
| `url` | string | Direct link to the project page on Freelancer.com. |
| `seoUrl` | string | URL slug portion (e.g. `shopify-plus-migration-custom-theme`). |
| `jobType` | string | `fixed` or `hourly`. |
| `language` | string | Language code declared by the employer. |

#### Budget & Currency

| Field | Type | Description |
|---|---|---|
| `currency` | string | ISO 4217 currency code (e.g. `USD`, `EUR`, `GBP`). |
| `budgetMin` | number | Minimum budget in the project's native currency. |
| `budgetMax` | number | Maximum budget in the project's native currency. |
| `budgetMinUsd` | number | The same minimum converted to US dollars, so budgets from every currency sort and average on one scale. |
| `budgetMaxUsd` | number | The same maximum converted to US dollars. `null` only when the employer posted an open-ended budget with no ceiling. |
| `budgetDisplay` | string | Human-readable budget label (e.g. `$1,500 - $4,500 USD`). Open-ended budgets read `from $10,000 USD` or `up to $500 USD`. Hourly projects carry the rate unit, exactly as Freelancer.com shows it: `$15 - $25 USD / hour`, `from $50 USD / hour`. |

#### Engagement & Bids

| Field | Type | Description |
|---|---|---|
| `bidCount` | integer | Number of bids submitted so far. |
| `bidAvg` | number | Average bid amount in the project's native currency. |
| `bidAvgUsd` | number | The same average bid converted to US dollars, so you can compare going rates across projects posted in different currencies without supplying your own exchange rates. |
| `skills` | array of strings | Skill tags the employer attached (e.g. `["Shopify", "Liquid"]`). |

#### Employer & Location

| Field | Type | Description |
|---|---|---|
| `country` | string | Lowercase 2-letter ISO country code of the employer. Taken from the location the employer published, otherwise from the country you filtered on. Filter by country and every row carries it; leave the filter blank and it is filled for the projects that publish a location, `null` for the rest. |
| `location` | string | City, region and country the employer published, e.g. `"Hayward, California, United States"`. Country names always come back in English, so the same place groups cleanly no matter what language the employer posts in. Present on local projects, where the employer wants someone on site; `null` on remote projects, which have no location to publish. |

#### Quality Badges

| Field | Type | Description |
|---|---|---|
| `featured` | boolean | Featured listing — paid placement boost. |
| `urgent` | boolean | Marked urgent by the employer. |
| `sealed` | boolean | Bids are hidden from competing freelancers. |
| `nda` | boolean | NDA required to view full details. |
| `recruiterAssisted` | boolean | A Freelancer.com recruiter is shortlisting candidates for this client — usually a sign of a bigger, better-funded brief. |
| `preferredFreelancerOnly` | boolean | Only Preferred Freelancer Program members can bid, so the field is far less crowded. |
| `ipAgreement` | boolean | The client requires an intellectual-property transfer agreement before work starts. |

#### Timestamps

| Field | Type | Description |
|---|---|---|
| `submitDate` | string | ISO 8601 UTC — when the project was posted. |
| `bidEndDate` | string | ISO 8601 UTC — when the bid window closes. |
| `timeLeft` | string | Human-readable countdown (e.g. `"3 days left"`, `"Closes today"`, `"Closed"`). |
| `scrapedAt` | string | ISO 8601 UTC — when this row was extracted. |

### Tips for Best Results

- **Drop the keyword for pure budget sorts.** When `searchQueries` is set, results are blended with a relevance score — for clean lowest-or-highest budget order, use `searchUrls` with `sortBy=budget_low` or `budget_high` and no query.
- **Combine `country=us` with `minBudget=1000`** to surface premium US clients in your timezone — one of the highest-ROI filter combinations for outreach.
- **Set the country filter when you want `country` on every row.** Freelancer only publishes a client location on on-site "local" projects, so an unfiltered run fills `country` for those and leaves it blank elsewhere rather than guessing from the payment currency.
- **Trim the page number off a pasted URL.** A URL ending in a page number tells the actor to skip that many projects from the start of its own result order, which is not the order the Freelancer.com website shows you. You still get real, matching projects, just not the exact cards you were looking at. Paste the URL without the page number and let `maxResults` decide how deep to go.
- **Set the budget boxes on Freelancer.com before you copy the URL.** The Fixed Price and Hourly min/max boxes in the site's own filter panel come across with the URL, already converted to US dollars, so the run applies the same range you were just looking at. Fill only one of the two pairs: a fixed-price range and an hourly rate range describe different things, and only one can be applied per URL.
- **Use `searchUrls` for category landing pages** like `https://www.freelancer.com/jobs/seo` to ride Freelancer's own skill taxonomy instead of guessing keywords.
- **Sort by `newest` for live monitoring.** Run the actor on a schedule (every 30 minutes) with a tight `maxResults` to capture fresh posts the moment they appear.
- **Filter by `projectType=hourly`** when benchmarking long-term retainers — fixed-price posts skew toward one-off work.
- **Watch `bidCount` for saturation.** Categories with average `bidCount` above 40 are crowded; below 15 means less competition for your bids.
- **Benchmark rates on `bidAvgUsd`, not `bidAvg`.** Roughly half of all active projects are posted outside the dollar, so averaging the native column mixes rupees with pounds and inflates the result many times over. Sort or average on `bidAvgUsd` and every row is on the same scale.
- **The default `maxResults=1000`** is the sweet spot for most queries — comprehensive enough to map an active niche, low enough to keep runs quick. Bump up to `10000` (or set to `0`) for full-market snapshots — and split those across two or more search terms or URLs, because a single search tops out near 5,000 projects and cannot fill a 10,000-row run on its own.

### Pricing

**From $0.95 per 1,000 results. No compute charges — you only pay per result returned.**

Apify's loyalty tiers discount every result you pull. Find your current tier in your Apify account billing page. Until October 25, 2026, every tier pays the Gold rate of $0.95 per 1,000 results; from that date the tier prices below apply.

| Results | No discount | Bronze | Silver | Gold |
|---|---|---|---|---|
| 100 | $0.113 | $0.107 | $0.101 | $0.095 |
| 1,000 | $1.13 | $1.07 | $1.01 | $0.95 |
| 10,000 | $11.30 | $10.70 | $10.10 | $9.50 |
| 100,000 | $113.00 | $107.00 | $101.00 | $95.00 |

Each run also carries a one-off $0.00005 start charge, which is less than a hundredth of a cent no matter how large the run. Billing is rounded to the nearest cent, and runs that return 0 results cost nothing.

### Integrations

- **Zapier & Make** — trigger downstream workflows when new high-budget projects appear.
- **Google Sheets** — push fresh listings into a sheet for your sales team to work each morning.
- **Apify API & webhooks** — kick off runs from your own backend or get notified the moment a run finishes.
- **CRM systems** — drop `projectId`, `country`, `budgetMax`, and `skills` directly into Salesforce, HubSpot, or Airtable as new lead records.
- **BI tools** — connect output datasets to Looker, Power BI, or Tableau for trend dashboards.

### Legal & Ethical Use

This actor extracts only **publicly listed active projects** — content that Freelancer.com surfaces to anonymous visitors. It does not access freelancer profiles, private bids, or any logged-in user data.

You are responsible for using the data lawfully. Respect Freelancer.com's Terms of Service, applicable data-protection laws (GDPR, CCPA), and any sender-permission rules (CAN-SPAM, GDPR consent) before contacting employers based on extracted information. Do not use the data for spam or harassment.

# Actor input Schema

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

Free-text keywords to search across active Freelancer.com projects (e.g. 'shopify', 'logo design', 'react native'). Each query produces its own set of results. Leave empty if you only want to use Search URLs below.

## `searchUrls` (type: `array`):

Paste one or more Freelancer.com URLs. Accepts category listings (e.g. https://www.freelancer.com/jobs/web-development), keyword searches (https://www.freelancer.com/search/projects?q=logo-design), or direct project pages. Filters in the URL are honored as-is, including the Fixed Price and Hourly budget boxes from the site's own filter panel (fill only one of those two pairs — a fixed-price range and an hourly rate range describe different things and only one can be applied per URL). If your URL includes a page number, please note: it skips that many projects from the start of THIS actor's own result order, which is not the same order the Freelancer.com website puts them in — so page 3 will give you 50 genuine matching projects, but not the same 50 cards you were just looking at in your browser. Copy the URL without the page number if you want a dependable starting point.

## `category` (type: `string`):

Restrict results to a Freelancer category. Leave blank to search across all categories.

## `projectType` (type: `string`):

Fixed-price projects pay a single agreed amount. Hourly projects bill by the hour.

## `minBudget` (type: `integer`):

Only keep projects whose posted budget starts at or above this amount. This looks at the budget the client advertised, not what freelancers have bid so far. Budgets posted in other currencies are converted to US dollars first. On hourly projects it is compared against the posted hourly rate. Leave empty for no minimum.

## `maxBudget` (type: `integer`):

Only keep projects whose posted budget tops out at or below this amount. Budgets posted in other currencies are converted to US dollars first. Open-ended budgets (for example "$500 and up") are left out because they have no ceiling. On hourly projects it is compared against the posted hourly rate. Leave empty for no maximum.

## `country` (type: `string`):

Restrict to projects posted by employers in a specific country. This matches the employer's own country, not the currency they pay in — a Malaysian client paying in US dollars is found under Malaysia, not the United States. Picking a country also fills the `country` column on every row. Leave blank for all countries; `country` is then filled only for the projects that publish an employer location.

## `sortBy` (type: `string`):

How to order project results. "Newest first" puts the most recently posted projects at the top. The budget options compare amounts in US dollars, so projects priced in different currencies rank fairly against each other, and a project posted with an open-ended budget like "$100,000 and up" is ranked by the amount it does state instead of being pushed to the end of the list. If you enter more than one Search Query or URL, each one is ordered on its own and the blocks follow each other in the dataset rather than merging into a single ranked list. Note: when a Search Query is set, Freelancer blends its own relevance score into which projects are returned.

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

Cap on total project rows across all queries and URLs. Default 1000 — lower for quick runs, raise for larger pulls, or set to 0 to request the full 10,000-row maximum. Keep in mind that any one search term or URL returns about 5,000 projects at most, so reaching 10,000 in a single run means using two or more of them. The actor stops requesting new pages once this number is reached but keeps the full final page, which can overshoot the cap by up to 99 rows on larger pulls. A cap below 100 is requested exactly, so a small run returns close to the number you asked for.

## Actor input object example

```json
{
  "searchQueries": [
    "seo"
  ],
  "searchUrls": [],
  "projectType": "all",
  "sortBy": "relevance",
  "maxResults": 1000
}
```

# Actor output Schema

## `overview` (type: `string`):

Active project listings at a glance — title, project type, the budget as posted plus both endpoints in US dollars, bid count and average bid in US dollars, skills, employer country, posted date, time left and the link. Every money column is on one scale so a mixed-currency result set can be scanned and sorted directly; the native-currency figures, the seven quality flags and the full description are on the Detailed view.

## `detail` (type: `string`):

Full per-project detail — every field including descriptions, both budget endpoints in the native currency and in US dollars, the USD-comparable average bid, bid timestamps, and the language code.

# 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 = {
    "searchQueries": [
        "seo"
    ],
    "searchUrls": [],
    "projectType": "all",
    "sortBy": "relevance",
    "maxResults": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/freelancer-com-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 = {
    "searchQueries": ["seo"],
    "searchUrls": [],
    "projectType": "all",
    "sortBy": "relevance",
    "maxResults": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/freelancer-com-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 '{
  "searchQueries": [
    "seo"
  ],
  "searchUrls": [],
  "projectType": "all",
  "sortBy": "relevance",
  "maxResults": 1000
}' |
apify call solidcode/freelancer-com-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,solidcode/freelancer-com-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/BvMwrN6UbegqLtM6a/builds/07F9UVUIjfEHs08Ec/openapi.json