# Upwork Job Scrapper Pro (`scrapfox/upwork-job-scrapper-pro`) Actor

Scrape Upwork job listings with full client insights: rating, total spend, country, and hire history, plus job title, budget, skills, and publish time. Filter by country and export to JSON, CSV, or Excel. Ideal for lead generation and market research.

- **URL**: https://apify.com/scrapfox/upwork-job-scrapper-pro.md
- **Developed by:** [ScrapFox](https://apify.com/scrapfox) (community)
- **Categories:** Lead generation, Jobs, Integrations
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## 🚀 Upwork Job Scraper: Authenticated Upwork Jobs Data at Scale (Zero Ban Risk to Your Account)

Scrape Upwork jobs the safe way. This Upwork Job Scraper pulls fresh, fully **authenticated** Upwork jobs data for you, powered by an in-house rotating cookie pool, sticky residential proxies, and automatic Cloudflare challenge handling. No cookies to paste. No setup. **Zero ban risk to your own Upwork account.**

Just clean, structured Upwork job listings loaded with rich client and budget detail, ready to plug into your dashboard, CRM, or AI pipeline.

> ⚡ **Read this first:** You get **authenticated results by default** (richer data, same price) **and** surgical filtering power across keywords, budgets, experience level, location, payment verification, job age, and custom rules. Both are the hero features here. 👇

***

### 🏆 Why Choose This Upwork Scraper?

Stop wasting hours refreshing Upwork search pages and guessing which filters actually work.

Most Upwork scrapers hand you thin, logged-out data. Or worse, they ask you to paste your own cookies and put your account at risk. This Upwork Job Scraper is built differently:

- 🔐 **Automatic Authentication (In-House Cookies):** Every run is authenticated through our own managed, rotating cookie pool. You get fully authenticated Upwork jobs data by default, with no cookies to paste and nothing to configure.
- 🧊 **0 Ban Risk to Your Account:** All traffic flows through our managed infrastructure (in-house accounts plus sticky residential proxies). Your personal Upwork login is never touched, so there's zero ban risk to your profile.
- 🛡️ **Anti-Bot, Handled For You:** Automatic **Cloudflare challenge handling**, sticky residential proxies, and human-like navigation are all built in. When a session is challenged, the scraper warms up, clears it, and rotates to a healthy identity if needed. You never fight Upwork's protection layer yourself.
- 📊 **More Data at the Same Price:** Authenticated sessions unlock richer job and client details (client spend, feedback score, review count, budgets, engagement duration) at no extra cost.
- 🎯 **Surgical Filtering Power:** Filter by keywords, budget ranges, experience level, job type, client hire history, location, and payment verification. Plus custom filters with operators for anything else.
- ⚙️ **Zero Setup, Works Out of the Box:** Built with JavaScript on Node.js for reliability. Paste a keyword (or a raw Upwork URL) and go.

Both are heroes here: bulletproof authenticated infrastructure, and the richest, most filterable Upwork job listings feed on the store.

***

### 🆕 What's New (Latest Update)

A major upgrade that makes your Upwork jobs data richer and more reliable:

- ✅ **Server-Rendered Extraction:** Reads Upwork's authenticated server-rendered results directly, so every job comes back with exact client spend, review counts, and precise feedback scores.
- ✅ **Automatic In-House Cookies:** Fully authenticated results by default. No need to provide your own cookies.
- ✅ **Custom Filters Engine:** Filter on almost any field with `includes` / `notIncludes` / `equals` / `notEquals` / `greaterThan` / `lessThan` / `gte` / `lte`.
- ✅ **Client Hire-History & Per-Page Controls:** New `clientHistory` buckets and `perPage` (10 / 20 / 50) options.
- ✅ **Same Price:** All of this at no additional cost.

> These features are live on every run. You don't need to change a thing to benefit from them.

***

### ⭐ Key Features: Filtering Power Meets Data Richness

- 🔎 **Customizable Search:** Keywords, budget ranges (fixed and hourly), experience level, job type, client hire history, location, and payment verification.
- 🔗 **Raw URL Support:** Paste any Upwork search URL directly and scrape it as-is.
- ⏳ **Job Age Filtering:** Keep only fresh jobs. Last 1, 6, 12, 24 hours, or last 3, 7 days.
- 🌍 **Location Filtering:** Target client location by broad region or specific country.
- 🧩 **Advanced Custom Filters:** Filter on almost any property using `includes`, `notIncludes`, `equals`, `notEquals`, `greaterThan`, `lessThan`, `gte`, `lte`. Everything is case-insensitive.
- 🔀 **Sorting:** Newest or relevance.
- 📄 **Pagination Controls:** Set how many pages to scrape and results per page (10 / 20 / 50).
- 🔐 **Managed Auth & Anti-Ban:** In-house rotating cookies, sticky residential proxies, Cloudflare challenge handling, health-based profile rotation.
- 🍪 **Optional Own Cookies:** Advanced users can still supply their own `master_access_token` and `oauth2_global_js_token`.
- 🧱 **Stack:** JavaScript on Node.js for stability and long-term maintainability.

***

### 👥 Who It's For (Use Cases)

- 👤 **Freelancers hunting niche jobs:** Surface exactly the projects you're qualified for without endless scrolling.
- 🏢 **Agencies monitoring demand:** Track what's hot in your niche in real time.
- 📊 **Market research teams:** Measure service demand and pricing across skills and regions.
- 🧠 **Competitive analysis:** See which skills clients request most and how much they actually pay.
- 🔔 **Fresh job alerts:** Schedule runs and catch new postings the moment they go live.
- 💼 **Lead generation:** Build a pipeline of clients actively hiring right now.
- 🧱 **Job boards & aggregators:** Power your own product with clean Upwork job listings.
- 🤖 **AI proposal automation:** Feed structured jobs into an LLM to draft tailored proposals.
- 📈 **Dashboards & CRMs:** Pipe Upwork jobs data straight into your existing stack.

***

### 🛠️ How to Use the Upwork Job Scraper

Getting started takes less than a minute:

1. **Set your parameters:** Enter a search keyword or paste a raw Upwork search URL. Optionally set job age, experience level, job type, budget ranges, client history, location, sorting, and custom filters.
2. **Run the scraper:** Launch it and let it work. Authenticated cookies, proxies, and Cloudflare handling all happen behind the scenes.
3. **Get your data:** Review structured Upwork job listings in the dataset, then export to JSON, CSV, or Excel. Or pull them via the Apify API.

> 💡 **Pro tip:** Start broad with just a keyword to see the shape of the data, then layer on filters to zero in on exactly the jobs you want.

***

### 🎛️ Filtering Options Deep-Dive

#### Standard filters

| Filter | Options |
|---|---|
| **Keyword** | Any search term (or a raw Upwork search URL) |
| **Experience Level** | Entry, Intermediate, Expert |
| **Job Type** | Fixed Price, Hourly |
| **Hourly Rate** | Min / Max ($/hr) |
| **Fixed Budget** | Min / Max ($) |
| **Client Hire History** | No hires, 1 to 9 hires, 10+ hires |
| **Payment Verification** | Only clients with a verified payment method |
| **Posted Within** | Last 1h / 6h / 12h / 24h / 3d / 7d |
| **Location** | Broad region or specific country (client location) |
| **Min Client Rating / Spend / Jobs Posted** | Client-quality thresholds (post-scrape) |
| **Sorting** | Newest or relevance |
| **Pagination** | Pages to scrape + results per page (10 / 20 / 50) |

**Posted-within example** (only jobs from the last 24 hours):

```json
{ "postedWithin": "24h" }
```

Accepted values: `1h`, `6h`, `12h`, `24h`, `3d`, `7d`.

**Location example** (clients in the United States, Europe, or Australia):

```json
{ "clientCountry": "United States, Europe, Australia" }
```

Supported broad regions: **Europe, North America, South America, Asia, Middle East, Oceania, Africa** (each expands to its member countries), plus any specific country name. Common variants are understood (US / USA / United States all work). Unrecognized names are ignored. Location is matched **post-scrape** against the client's country. Jobs with no captured country are dropped when this filter is set.

***

### 🧩 Custom Filters (any property, any operator)

Apply your own rules on top of the standard filters. A job is kept only if it passes **every** rule.

**Filterable properties:** `title`, `description`, `jobType`, `experienceLevel`, `budget`, `fixedPrice`, `hourlyMin`, `hourlyMax`, `tags`, `duration`, `proposals`, `country` (client location), `clientRating`, `clientSpend`, `jobsPosted`, `url`.

**Operators:** `includes`, `notIncludes`, `equals`, `notEquals`, `greaterThan`, `lessThan`, `gte`, `lte`. All string comparisons are **case-insensitive**. For array fields like `tags`, `includes` and `notIncludes` check whether **any** tag matches.

> Missing-field behavior: a positive operator (`includes`, `equals`, `greaterThan`, etc.) drops a job whose field is absent. A negative operator (`notIncludes`, `notEquals`) keeps it.

**Example: Python expert jobs, no WordPress:**

```json
[
  { "key": "title", "operator": "includes", "value": "python" },
  { "key": "experienceLevel", "operator": "equals", "value": "Expert" },
  { "key": "tags", "operator": "notIncludes", "value": "wordpress" }
]
```

**Example: numeric thresholds (client rating ≥ 4.5, hourly floor ≥ 30):**

```json
[
  { "key": "clientRating", "operator": "gte", "value": "4.5" },
  { "key": "hourlyMin", "operator": "greaterThan", "value": "30" }
]
```

***

### 📦 Output Format: Rich, Structured Upwork Jobs Data

Every run produces a clean dataset. Each Upwork job includes:

| Field | Description |
|---|---|
| 🆔 `id` / `subId` / `url` | Job identifier (ciphertext), secondary record id, and direct link |
| 📝 `title` / `description` | Full job title and complete description |
| ⏱️ `type` / `jobType` | Contract type: `Hourly` or `Fixed Price` |
| 💰 `budget` | Human-readable budget string (e.g. `"$40-$80/hr"` or `"$1500"`) |
| 💵 `budgetMin` / `budgetMax` / `currency` | Numeric budget bounds |
| 📊 `experienceLevel` | Entry Level, Intermediate, or Expert |
| 🛠️ `skills` / `tags` | Required skills and job tags |
| ⏳ `duration` | Engagement / project length |
| 📨 `proposals` | Applicant count tier |
| 🌍 `clientLocation` | Client's country |
| ✅ `clientPaymentVerified` | `"Yes"` / `"No"` |
| 💳 `clientTotalSpent` | Lifetime client spend (e.g. `"$125000"`) |
| ⭐ `clientRating` | Client feedback score (0 to 5) |
| 🗣️ `clientTotalReviews` | Number of client reviews |
| 📁 `clientTotalJobsPosted` | Number of jobs the client has posted |
| 📅 `publishedTime` / `relativeDate` | When the job was published (absolute plus relative when available) |
| 🕔 `scrapedAt` | When this record was captured |

**Example output:**

```json
{
  "id": "~021955020056847176693",
  "subId": "1955020056847176693",
  "title": "Senior Python Web Scraping Developer",
  "url": "https://www.upwork.com/jobs/~021955020056847176693",
  "description": "Looking for an experienced Python developer to build data extraction pipelines...",
  "type": "Hourly",
  "jobType": "Hourly",
  "budget": "$40-$80/hr",
  "budgetMin": 40,
  "budgetMax": 80,
  "currency": "USD",
  "experienceLevel": "Expert",
  "skills": ["Python", "Web Scraping", "Selenium", "API Integration"],
  "tags": ["Python", "Web Scraping", "Selenium", "API Integration"],
  "duration": "1 to 3 months",
  "proposals": 12,
  "clientLocation": "United States",
  "clientPaymentVerified": "Yes",
  "clientTotalSpent": "$125000",
  "clientRating": 4.95,
  "clientTotalReviews": 42,
  "clientTotalJobsPosted": 58,
  "publishedTime": "Mar 18, 2026, 10:30 AM UTC",
  "relativeDate": "Unspecified",
  "scrapedAt": "Mar 18, 2026, 12:30 PM UTC"
}
```

> Note: `relativeDate` (e.g. `"Posted 2 hours ago"`) is populated when the job is read from the rendered tile. For server-rendered results the absolute `publishedTime` is provided instead and `relativeDate` is `"Unspecified"`. Numeric client fields are `null` or `"N/A"` when Upwork doesn't expose them for a given job.

You can export the data in **JSON, CSV, or Excel**, or pull it programmatically through the **Apify API**.

***

### 🍪 Using Your Own Cookies (Optional)

You do **not** need cookies. The scraper uses in-house authentication automatically.

But if you'd like results exactly as a specific account sees them, you can supply your own from a logged-in Upwork session:

```json
[
  { "name": "master_access_token", "value": "your-cookie-value-here" },
  { "name": "oauth2_global_js_token", "value": "another-cookie-value" }
]
```

Only `name` and `value` are required. When you provide these, the scraper uses your cookies instead of the in-house pool.

***

### 🔌 Integrations and Automation

Your Upwork Job Scraper plus the Apify platform equals a full data pipeline:

- ⏰ **Schedule** runs hourly or daily for continuous Upwork job monitoring and fresh alerts.
- 🔗 **Integrate** with Zapier, Make, n8n, Google Sheets, Slack, and webhooks.
- 🧑‍💻 **Apify API clients** for JavaScript, Python, and more. Run it as your own Upwork jobs API.
- 🤖 **MCP support** lets AI assistants and agents call the scraper directly for proposal-automation workflows.

***

### 💸 Pricing, Billing, and Free Tier

Transparent, pay-as-you-go pricing.

| | Free tier (non-paying Apify users) | Paid Apify plan |
|---|---|---|
| **Runs** | 30 runs per calendar month | Unlimited |
| **When exhausted** | Actor exits cleanly with an upgrade message | n/a |

- **Free-tier counting:** A free-user run is counted live from the Apify Runs API when the scrape starts (per UTC calendar month), even if it returns 0 matching jobs. Once the monthly quota is hit, the actor exits gracefully and tells you to upgrade. Paying users are unlimited.
- **Fails open:** If the plan or run count can't be determined, the run proceeds. Metering never bricks a legitimate run.
- **The value:** Because sessions are authenticated, you get richer client stats, budgets, and engagement details on every job than logged-out scrapers, at the same price.

> Per-result pricing and any minimum billing are configured on the Apify actor listing.

***

### ❓ FAQ

**What is the Upwork Job Scraper?**
An Apify Actor that extracts Upwork job listings (titles, descriptions, budgets, skills, client stats, and more) into structured JSON, CSV, or Excel. It's the fastest way to scrape Upwork jobs without building and maintaining your own scraper.

**Do I need an Upwork account or cookies?**
No. Authentication is handled automatically through our in-house rotating cookie pool. Nothing to paste, and zero ban risk to your own account. Supplying your own cookies is completely optional.

**Will scraping Upwork get my account banned?**
No, your account is never used. All requests run through our managed infrastructure (in-house accounts plus sticky residential proxies), so your personal Upwork profile is never exposed.

**How does it get past Upwork's bot protection?**
Warmed authenticated sessions plus human-like navigation clear Cloudflare challenges, and unhealthy identities are automatically rotated out. There's no CAPTCHA-solving service involved. The goal is to look like a real logged-in browser so challenges clear on their own.

**How is this different from Upwork's official API?**
Upwork offers a public GraphQL API that uses OAuth 2.0 and requires an approved developer key (with ID verification through Upwork's API Center). This scraper is a practical alternative: no key-approval process, flexible filtering, richer public job and client data, and delivery through the Apify API.

**How do I filter by country?**
Use the location filter (broad region or specific country) to target where the **client** is located.

**Can I get real-time Upwork job alerts?**
Yes. Schedule the actor on Apify and connect it to Slack, Telegram, email, or a webhook via Zapier, Make, or n8n for near real-time monitoring.

**What data can I extract?**
Job id, subId, URL, title, description, budget (fixed or hourly range), client stats (total spent, review count, feedback score, jobs posted), skills, tags, proposals, published time, contract type, engagement duration, payment verification, and client location.

**Is it legal to scrape Upwork?**
This scraper only extracts publicly available job-listing data. No private user data. Always review Upwork's Terms of Service and applicable laws (including GDPR), and avoid collecting personal data without a legitimate reason. You're responsible for your own use case.

**Which formats can I export?**
JSON, CSV, and Excel, plus programmatic access via the Apify API in JavaScript, Python, and other languages.

***

### 🚀 Start Scraping Upwork Jobs Now

Turn Upwork into a clean, structured, always-fresh data feed. Safely, at scale, with zero setup.

Whether you're a freelancer hunting niche gigs, an agency mapping demand, or a builder powering an AI proposal pipeline, this Upwork Job Scraper delivers rich, authenticated Upwork jobs data with **0 ban risk** to your account.

👉 Click **"Try for free"** and run your first scrape in under a minute. 🎯

# Actor input Schema

## `keyword` (type: `string`):

The job search term, e.g. 'react developer' or 'logo design'. Required UNLESS you provide a Raw Search URL (Advanced) instead.

## `maxPages` (type: `integer`):

How many result pages to scrape (~10 jobs per page).

## `perPage` (type: `string`):

How many jobs Upwork returns per result page (10, 20, or 50). A higher value fetches more jobs per page load, so fewer pages are paginated for the same job count. Leave blank for Upwork's default (~10). NOTE: server-side — confirm Upwork honors it in a live run.

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

Order of the search results.

## `jobTypes` (type: `array`):

Which pricing types to include. Select both to include everything.

## `hourlyMin` (type: `integer`):

Only hourly jobs paying at least this rate. Leave blank for no minimum.

## `hourlyMax` (type: `integer`):

Only hourly jobs paying up to this rate. Leave blank for no maximum.

## `fixedMin` (type: `integer`):

Only fixed-price jobs with a budget at least this large. Leave blank for no minimum.

## `fixedMax` (type: `integer`):

Only fixed-price jobs with a budget up to this large. Leave blank for no maximum.

## `experienceLevels` (type: `array`):

Which experience levels to include. Select all to include everything.

## `postedWithin` (type: `string`):

Only include jobs posted within this window (applied after scraping).

## `paymentVerifiedOnly` (type: `boolean`):

Only jobs from clients who have verified a payment method (filtered on Upwork's side).

## `clientHistory` (type: `array`):

Only jobs from clients in these lifetime-hire buckets. NOTE: mapped to Upwork's client\_hires search param (server-side) — confirm it works in a live run.

## `clientCountry` (type: `string`):

Filter by client location. Type one or more full country names OR regions separated by commas — for example: united states, canada, europe. Regions understood: Europe, North America, South America, Asia, Middle East, Oceania, Africa (each expands to its countries). Common country variants are understood (US / USA / United States all work). Any misspelled or unrecognized name is ignored. Leave blank for anywhere. NOTE: jobs where the client's country wasn't captured are excluded when this filter is set.

## `minClientRating` (type: `number`):

Only clients rated at least this (0-5). Jobs with no captured rating are excluded.

## `minClientSpend` (type: `integer`):

Only clients who have spent at least this total on Upwork. Jobs with no captured spend are excluded.

## `minJobsPosted` (type: `integer`):

Only clients who have posted at least this many jobs. Jobs with no captured count are excluded.

## `rawUrl` (type: `string`):

Advanced: scrape this exact Upwork search URL instead of building one from the filters above. Overrides all filters. Still goes through login warm-up.

## `customFilters` (type: `array`):

Post-scrape rules applied to every job; a job is kept only if it passes ALL rules. Each rule is an object {"key", "operator", "value"}. Keys: title, description, tags, jobType, experienceLevel, duration, proposals, budget, fixedPrice, hourlyMin, hourlyMax, country, clientRating, clientSpend, jobsPosted. Operators: includes, notIncludes, equals, notEquals, greaterThan, lessThan, gte, lte. Missing field: a positive operator drops the job, a negative one keeps it. Example: \[{"key":"title","operator":"includes","value":"python"},{"key":"tags","operator":"notIncludes","value":"wordpress"}]

## `timezone` (type: `string`):

IANA timezone used to show the job's Published Time (and Scraped At) in your local time — Upwork times are UTC. Examples: America/New\_York, Europe/London, Asia/Kolkata, Asia/Karachi. Leave blank to keep UTC.

## Actor input object example

```json
{
  "keyword": "next js developer",
  "maxPages": 3,
  "sortBy": "recency",
  "jobTypes": [
    "hourly",
    "fixed"
  ],
  "experienceLevels": [
    "entry",
    "intermediate",
    "expert"
  ],
  "postedWithin": "24h",
  "paymentVerifiedOnly": false,
  "clientCountry": "united states, europe",
  "timezone": "America/New_York"
}
```

# Actor output Schema

## `jobs` (type: `string`):

Scraped Upwork job listings, one item per job: id, subId, url, title, description, type/jobType, budget (+ budgetMin/Max/currency), experienceLevel, skills, tags, duration, proposals, clientLocation, clientPaymentVerified, clientTotalSpent, clientRating, clientTotalReviews, clientTotalJobsPosted, publishedTime, relativeDate, and scrapedAt. See the dataset schema for field descriptions and the Overview table view.

## `executionSummary` (type: `string`):

A single per-run summary record: keyword, sortBy, pages requested, raw/filtered/saved job counts, duration, profile-pool health, proxy health, and an error tally. Useful for monitoring and debugging a run.

# 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 = {
    "maxPages": 3,
    "jobTypes": [
        "hourly",
        "fixed"
    ],
    "experienceLevels": [
        "entry",
        "intermediate",
        "expert"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapfox/upwork-job-scrapper-pro").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 = {
    "maxPages": 3,
    "jobTypes": [
        "hourly",
        "fixed",
    ],
    "experienceLevels": [
        "entry",
        "intermediate",
        "expert",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapfox/upwork-job-scrapper-pro").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 '{
  "maxPages": 3,
  "jobTypes": [
    "hourly",
    "fixed"
  ],
  "experienceLevels": [
    "entry",
    "intermediate",
    "expert"
  ]
}' |
apify call scrapfox/upwork-job-scrapper-pro --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/cZkvVjd1OVOtQQoPW/builds/RazeznwzY0LaYYDGF/openapi.json