# Upwork Freelancer & Talent Scraper (`parseforge/upwork-scraper`) Actor

Scrape Upwork freelancer profiles by keyword. Extract names, titles, countries, Job Success Scores, total earnings, skills, and agency info. Export to CSV, Excel, JSON, XML.

- **URL**: https://apify.com/parseforge/upwork-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Jobs, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 💼 Upwork Freelancer & Talent Scraper

> 🚀 **Export Upwork freelancer profiles in seconds.** Search by any keyword and get names, titles, countries, Job Success Scores, total earnings, skills, agency info, and availability - no login required, ready to download as CSV, Excel, JSON, or XML.

> 🕒 **Last updated:** 2026-05-21 · **📊 22 fields** per record · **Up to 1,000,000 freelancers** · **Global coverage**

The Upwork Freelancer & Talent Scraper lets you extract public freelancer data from Upwork's talent marketplace at scale. Provide one or more search keywords (e.g. "react developer", "graphic designer", "copywriter"), and the scraper pages through Upwork's public search results collecting every freelancer card it finds. All data comes directly from Upwork's live public pages - no login, no API key, no Upwork account needed.

The dataset includes the 22 most useful public signals per freelancer: profile image, professional headline, country, Upwork tier badge (Top Rated Plus / Top Rated / Rising Talent / Expert-Vetted), Job Success Score, total lifetime earnings, skills list, agency affiliation, availability badge, consultation flag, search position, and more. Perfect for recruiters building talent pipelines, researchers studying the gig economy, or businesses benchmarking freelancer rates.

**Coverage:** Upwork lists 139,000+ freelancers for competitive keywords like "react developer". The scraper handles deep pagination (up to 50 pages per query) and deduplicates records across runs. Residential US proxies + Camoufox browser fingerprinting ensure reliable extraction through Cloudflare protection.

| Who uses this | Why |
|---|---|
| Recruiters & HR teams | Build shortlists of vetted freelancers without manual search |
| Freelance platforms | Competitive intelligence on talent supply and pricing signals |
| Market researchers | Analyze gig economy trends, skill distributions, and earnings |
| Startup founders | Find Top Rated Plus developers, designers, and writers quickly |
| Data scientists | Train models on freelancer bio text, skills, and reputation data |
| Lead generation agencies | Identify high-earning freelancers as potential B2B clients |

### 📋 What the Upwork Scraper does

- Searches Upwork's public talent marketplace for any keyword or set of keywords
- Paginates through all result pages (up to 50 pages per query, ~13 freelancers per page)
- Extracts all 22 publicly visible fields from each freelancer card
- Deduplicates records across multiple search terms in a single run
- Handles Cloudflare bot protection using stealth browser + residential US proxy
- Exports to CSV, Excel, JSON, and XML via the Apify platform

> 💡 **Why it matters:** Upwork has over 18 million registered freelancers. Manual search only shows a few pages. This scraper unlocks bulk access to the full public talent pool for any skill category - in minutes, not days.

### 🎬 Full Demo

_🚧 Coming soon_

### ⚙️ Input

<table>
<thead><tr><th>Field</th><th>Type</th><th>Required</th><th>Default</th><th>Description</th></tr></thead>
<tbody>
<tr><td><strong>searchTerms</strong></td><td>array</td><td>No</td><td>["react developer"]</td><td>List of keywords to search on Upwork talent marketplace. Each term is searched independently.</td></tr>
<tr><td><strong>maxItems</strong></td><td>integer</td><td>No</td><td>10</td><td>Maximum number of freelancer records to collect. Free users: capped at 10. Paid users: up to 1,000,000.</td></tr>
</tbody>
</table>

**Example 1 - Single keyword, 50 results:**
```json
{
  "searchTerms": ["react developer"],
  "maxItems": 50
}
````

**Example 2 - Multiple keywords, larger dataset:**

```json
{
  "searchTerms": ["react developer", "python developer", "ui ux designer", "copywriter"],
  "maxItems": 500
}
```

> ⚠️ **Good to Know:** The scraper uses residential US proxies to access Upwork's public search. Free accounts are limited to 10 freelancer records. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) to get started, then upgrade for full access.

### 📊 Output

Each record contains 22 fields:

| Field | Type | Description |
|---|---|---|
| 🖼 `imageUrl` | string | Freelancer profile picture URL |
| 🧑 `name` | string | Freelancer display name |
| 📌 `title` | string | Professional headline |
| 🔗 `url` | string | Full Upwork profile URL |
| 🆔 `id` | string | Upwork contractor unique ID |
| 🌍 `country` | string | Freelancer country |
| 🏅 `tier` | string | Top Rated Plus / Top Rated / Rising Talent / Expert-Vetted |
| ⭐ `jobSuccessScore` | integer | Job Success Score percentage (0-100) |
| 💵 `totalEarnings` | string | Lifetime earnings label, e.g. "$300K+" |
| 💵 `totalEarningsValueMin` | integer | Numeric earnings floor in USD (e.g. 300000) |
| 📝 `description` | string | Full bio / overview text |
| 🛠 `skills` | array | List of skill tags |
| 🎯 `jobsRelevantToSearch` | integer | Count of past jobs relevant to the search query |
| 💡 `recommendedReason` | string | Upwork recommendation label |
| 🟢 `isAvailableNow` | boolean | Has "Available Now" badge |
| 💬 `offersConsultations` | boolean | Offers paid consultations |
| 🚀 `isBoosted` | boolean | Paid boosted listing |
| 🏢 `agencyName` | string | Agency name if affiliated |
| 🏢 `agencyEarnings` | string | Agency total earnings label |
| 🔍 `searchTerm` | string | Keyword that returned this freelancer |
| 📊 `searchPosition` | integer | Position in search results (1-based) |
| 🕒 `scrapedAt` | string | ISO timestamp of collection |
| ❌ `error` | string | Error message if collection failed |

**Sample records (real data from 2026-05-21):**

```json
[
  {
    "imageUrl": "https://www.upwork.com/profile-portraits/c1GyxylmbwyRDMzLnTieLbYbtAhDZRD3HTLPFtGFsI0jm3I4sQrbMr8LV3iqXfkiq1",
    "name": "Yurij M.",
    "title": "React Developer | Full Stack Developer React | Frontend React Next.js",
    "url": "https://www.upwork.com/freelancers/~01dc05c3dd4817bee4",
    "id": "1463815904098725888",
    "country": "Ukraine",
    "tier": "Top Rated Plus",
    "jobSuccessScore": 100,
    "totalEarnings": "$300K+",
    "totalEarningsValueMin": 300000,
    "skills": ["CSS", "JavaScript", "React", "Redux", "Node.js", "HTML5", "TypeScript", "Vue.js", "MongoDB"],
    "jobsRelevantToSearch": 23,
    "recommendedReason": "23 jobs related to your search",
    "isAvailableNow": true,
    "offersConsultations": true,
    "isBoosted": false,
    "agencyName": "Soft Bee",
    "agencyEarnings": "$400K+",
    "searchTerm": "react developer",
    "searchPosition": 1,
    "scrapedAt": "2026-05-21T12:19:54.288Z",
    "error": null
  },
  {
    "imageUrl": "https://www.upwork.com/profile-portraits/c1pPxfzLZCY5gqzbPmuHHwcwuAUfPQP8dRhg71efx-E50MwEYq7TN0qPr_gT0kOjgP",
    "name": "Mykhailo D.",
    "title": "Front End Developer React Developer Full Stack Developer React Native",
    "url": "https://www.upwork.com/freelancers/~01b46d301b6827ab0c",
    "id": "1143921350420840448",
    "country": "Ukraine",
    "tier": "Top Rated Plus",
    "jobSuccessScore": 100,
    "totalEarnings": "$400K+",
    "totalEarningsValueMin": 400000,
    "skills": ["CSS", "Front-End Development", "JavaScript", "React", "Node.js", "TypeScript", "Next.js", "Python"],
    "jobsRelevantToSearch": 8,
    "recommendedReason": "8 jobs related to your search",
    "isAvailableNow": true,
    "offersConsultations": true,
    "isBoosted": false,
    "agencyName": "Hoverla Soft",
    "agencyEarnings": "$100K+",
    "searchTerm": "react developer",
    "searchPosition": 2,
    "scrapedAt": "2026-05-21T12:19:54.289Z",
    "error": null
  },
  {
    "imageUrl": "https://www.upwork.com/profile-portraits/c1z0rS30VbTRWd9Tmq-OxDg3GKXBG_KbON50H-vmqWffPe94BNt70Hwd7u5N_tgkTy",
    "name": "Raman A.",
    "title": "React Developer / Full Stack Developer / Full Stack Cursor / PM",
    "url": "https://www.upwork.com/freelancers/~011ea97aeb9206b2a7",
    "id": "424277385188458496",
    "country": "Lithuania",
    "tier": "Top Rated",
    "jobSuccessScore": 100,
    "totalEarnings": "$700K+",
    "totalEarningsValueMin": 700000,
    "skills": ["CSS", "Front-End Development", "JavaScript", "React", "Python", "Node.js", "TypeScript", "Laravel", "WordPress"],
    "jobsRelevantToSearch": 7,
    "recommendedReason": "7 jobs related to your search",
    "isAvailableNow": true,
    "offersConsultations": true,
    "isBoosted": false,
    "agencyName": "CreativeIT",
    "agencyEarnings": "$1M+",
    "searchTerm": "react developer",
    "searchPosition": 3,
    "scrapedAt": "2026-05-21T12:19:54.350Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

| Feature | Benefit |
|---|---|
| 🧠 Stealth browser + Camoufox | Bypasses Cloudflare bot protection reliably |
| 🌐 Residential US proxies | Real user IP fingerprint for consistent access |
| 📊 22 fields per freelancer | More complete than manual copy-paste or basic scrapers |
| 🔁 Multi-keyword batch runs | One run, multiple search terms, deduplicated output |
| 💰 Earnings data included | `totalEarnings` and numeric `totalEarningsValueMin` for easy sorting/filtering |
| 🏅 Tier badges captured | Filter by Top Rated Plus, Top Rated, Rising Talent, Expert-Vetted |
| 🟢 Availability flag | `isAvailableNow` - immediately filter for ready-to-hire talent |
| 📦 4 export formats | CSV, Excel, JSON, XML - download directly from Apify |
| 🔌 API + webhooks | Integrate with Make, Zapier, Slack, Google Sheets |

### 📈 How it compares to alternatives

| Method | Speed | Scale | Cost | Reliability |
|---|---|---|---|---|
| **This Actor** | Fast (auto-paginated) | Up to 1,000,000 | Pay-per-use | High (stealth + proxy) |
| Manual Upwork search | Very slow | ~100 results per session | Free | N/A |
| Upwork API (official) | Fast | Limited by rate limits | Requires partner status | High |
| Generic web scraper | Variable | Limited | Variable | Low (blocked easily) |

### 🚀 How to use

1. [Create a free Apify account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. Open the [Upwork Freelancer Scraper](https://apify.com/parseforge/upwork-scraper) on Apify Store
3. Click **Try for free**
4. Enter your search terms (e.g. "react developer", "copywriter")
5. Set `maxItems` to the number of freelancers you need
6. Click **Start** and wait for the run to complete
7. Download your dataset as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Talent Acquisition & Recruiting

Build targeted shortlists of vetted freelancers for any skill category. Filter by tier (Top Rated Plus only), country, JSS above 95%, or availability. Export to your ATS or Google Sheets for team review. A search for "python developer" returns 100+ Top Rated candidates with full bios and skills - in minutes.

#### Competitor & Market Intelligence

Monitor how many Top Rated Plus freelancers exist in your niche. Track the distribution of earnings tiers ($10K+, $100K+, $1M+) to understand market maturity. Compare skill frequency across categories. Run weekly to spot emerging skill trends before your competitors.

#### Sales & Lead Generation

Identify high-earning freelancers ($100K+, $300K+) as potential agency clients or SaaS customers. The `totalEarningsValueMin` field enables precise numeric filtering. Freelancers with `agencyEarnings` of $1M+ are running substantial operations and may need professional services.

#### Academic & Gig Economy Research

Download thousands of freelancer bios, country data, and earnings bands for quantitative research. Analyze the geography of high-earning freelancers, skill clustering, the premium commanded by Top Rated vs. Rising Talent badges, and the distribution of JSS scores across categories.

### 🔌 Automating Upwork Scraper

Connect the Upwork Scraper to your workflow tools:

- **Make (formerly Integromat):** Trigger a run on schedule, send results to Google Sheets or Airtable
- **Zapier:** Auto-push new freelancer records to HubSpot, Notion, or Slack
- **Slack:** Alert your team when a new batch of Top Rated Plus candidates is ready
- **Google Sheets:** Live-sync freelancer data for collaborative review
- **REST API:** `POST /v2/acts/parseforge~upwork-scraper/runs` - fully scriptable

### 🌟 Beyond business use cases

#### Research & Academia

Study the global distribution of freelance labor, skill premiums, and the effect of Upwork badge tiers on earnings. With 22 structured fields per record, datasets of 10,000+ freelancers are ready for regression analysis, NLP on bio text, or geographic clustering.

#### Non-profit & Education

Career counseling organizations can show students real earning outcomes for skills like "data scientist" or "ux designer." See which skills command $300K+ lifetime earnings vs. which are saturated.

#### Creative & Content Projects

Journalists and podcasters covering the future of work can pull live statistics - how many Top Rated Plus React developers are available right now? What percentage list agency affiliations? Fresh data in minutes.

#### Experimentation & Side Projects

Build a freelancer comparison tool, a skills-demand tracker, or a JSS benchmark dashboard. The consistent 22-field schema makes integration into any app straightforward.

### 🤖 Ask an AI assistant about this scraper

Not sure what to scrape or how to use the data? Paste this into ChatGPT, Claude, or any AI assistant:

> "I have a CSV of Upwork freelancer profiles with fields: name, title, country, tier, jobSuccessScore, totalEarnings, totalEarningsValueMin, skills, agencyName, isAvailableNow. Help me: 1) filter for Top Rated Plus freelancers with JSS >= 95, 2) rank by totalEarningsValueMin descending, 3) extract the top 5 most common skills."

The AI can write the Python/Excel formula instantly. Your dataset is the fuel.

### ❓ Frequently Asked Questions

**🔒 Do I need an Upwork account?**
No. The scraper accesses Upwork's public talent search pages - the same results you'd see browsing without logging in.

**📊 How many freelancers can I get per search term?**
Upwork returns up to ~13 results per page and allows up to 50 pages of pagination, giving approximately 650 results per keyword. For popular terms like "react developer", the scraper finds 139,000+ listed results. Use multiple keywords to maximize coverage.

**🌍 Can I filter by country?**
Not directly in the input - Upwork's public search doesn't expose a country filter in the URL. However, every record includes the `country` field, so you can filter the exported dataset in Excel or with a script.

**💰 How is `totalEarningsValueMin` calculated?**
Upwork shows earnings as labels like "$300K+". The scraper parses this to a numeric floor (e.g. 300000). Use this field to sort or filter freelancers by earning tier programmatically.

**🏅 What does the `tier` field contain?**
One of: `Top Rated Plus`, `Top Rated`, `Rising Talent`, `Expert-Vetted`, or null if no badge is shown. Top Rated Plus = top 3% of talent by Upwork's criteria.

**🔄 Can I run it on a schedule?**
Yes. Use the Apify Scheduler to run weekly or daily and keep your talent database fresh. Combine with Make or Zapier to auto-sync to Google Sheets.

**⏱ How long does a 100-item run take?**
Typically 3-8 minutes depending on Cloudflare response time and proxy routing. The stealth browser requires a warmup step on the Upwork homepage before searching.

**🆓 What do free users get?**
Free users get 10 freelancer records per run - enough to verify the data quality and field coverage. [Upgrade to a paid plan](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock up to 1,000,000 records.

**🔌 Can I use the data with an API?**
Yes. Every Apify dataset is accessible via REST API. Fetch results as JSON: `GET https://api.apify.com/v2/datasets/{datasetId}/items?format=json`

**🛡 Is this legal?**
The scraper only accesses publicly available data - the same information visible to any visitor browsing Upwork without an account. Always use scraped data in compliance with applicable laws and Upwork's terms of service.

**📁 What export formats are available?**
CSV, Excel (.xlsx), JSON, XML, RSS - all available directly from the Apify dataset UI or API.

**🔍 Can I search for freelancers in a specific category?**
Yes - use Upwork-style keyword searches: "logo designer", "video editor", "seo specialist", "wordpress developer", etc. The more specific the keyword, the more targeted the results.

### 🔌 Integrate with any app

The Upwork Scraper dataset is accessible via Apify's standard integrations:

**Storage & Productivity:** Google Sheets, Airtable, Notion, Microsoft Excel, OneDrive

**Automation:** Make (Integromat), Zapier, n8n, Activepieces

**CRM & Sales:** HubSpot, Salesforce, Pipedrive, Close

**Data & Analytics:** BigQuery, Snowflake, PostgreSQL, MongoDB, Metabase

**Communication:** Slack, Microsoft Teams, Discord, Email (SendGrid)

**Developer:** REST API, Webhooks, JavaScript SDK, Python SDK

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [PeoplePerHour Jobs Scraper](https://apify.com/parseforge/peopleperhour-jobs-scraper) | Scrape freelance job postings from PeoplePerHour |
| [LinkedIn People Scraper](https://apify.com/apify/linkedin-people-search) | Extract professional profiles from LinkedIn |
| [G2 Reviews Scraper](https://apify.com/parseforge/g2-reviews-scraper) | Collect software reviews and ratings from G2 |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for scrapers covering jobs, reviews, e-commerce, travel, and more - all production-ready and regularly maintained.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** This is an independent tool and is not affiliated with, endorsed by, or connected to Upwork in any way. Only publicly available data is collected - the same information visible to any visitor browsing Upwork without an account. Use this data responsibly and in compliance with applicable laws and Upwork's terms of service.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords used to search the Upwork talent marketplace (e.g. 'react developer', 'graphic designer', 'copywriter'). The scraper iterates through Upwork's public talent search results for each term and harvests every freelancer card it finds.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "searchTerms": [
    "react developer"
  ],
  "maxItems": 10
}
```

# 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 = {
    "searchTerms": [
        "react developer"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/upwork-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 = {
    "searchTerms": ["react developer"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/upwork-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 '{
  "searchTerms": [
    "react developer"
  ],
  "maxItems": 10
}' |
apify call parseforge/upwork-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Upwork Freelancer & Talent Scraper",
        "description": "Scrape Upwork freelancer profiles by keyword. Extract names, titles, countries, Job Success Scores, total earnings, skills, and agency info. Export to CSV, Excel, JSON, XML.",
        "version": "0.1",
        "x-build-id": "iCUsEoKhN6B6RBRvu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~upwork-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-upwork-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/parseforge~upwork-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-upwork-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/parseforge~upwork-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-upwork-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": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Keywords used to search the Upwork talent marketplace (e.g. 'react developer', 'graphic designer', 'copywriter'). The scraper iterates through Upwork's public talent search results for each term and harvests every freelancer card it finds.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
