# Upwork Job Scraper (`neatrat/upwork-job-scraper`) Actor

Scrape Upwork jobs without limits 🌟 Bypass CAPTCHAs & apply custom filters.

Apify is retiring rental Actors, so pricing is changing. For many users around ~7k jobs/month, cost should stay near the old $25. You still get the same no-cookie setup, with in-house Upwork accounts and proxies built in.

- **URL**: https://apify.com/neatrat/upwork-job-scraper.md
- **Developed by:** [Neatrat](https://apify.com/neatrat) (community)
- **Categories:** Automation, Lead generation, Jobs
- **Stats:** 4,910 total users, 666 monthly users, 99.9% runs succeeded, 137 bookmarks
- **User rating**: 4.83 out of 5 stars

## Pricing

from $3.20 / 1,000 jobs

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Upwork Job Listings Scraper

### Why This Scraper?
Stop manually refreshing Upwork search pages and guessing which filters to use. The **Upwork Job Listings Scraper** continuously pulls fresh, fully authenticated job data for you — safely, reliably, and without any complex setup.

Whether you're a freelancer tracking niche opportunities or an agency monitoring demand in your niche, this scraper turns Upwork into a clean, structured data feed you can actually work with.

### 🚀 Key Advantages (Read This First)

- ✅ **Automatic Authentication (In‑House Cookies)** – You now get **fully authenticated results by default**. No need to paste your own cookies anymore.
- 🔐 **0‑Hassle Anti‑Bot Handling** – **Automatic CAPTCHA solving** and **automatic rotating proxies** are built in, so you don't have to fight Upwork's protection.
- 🧊 **0 Ban Risk** – All traffic goes through our managed infrastructure (in‑house cookies + proxies), dramatically reducing the risk to your own account.
- 📊 **More Data, Same Price** – Authenticated sessions unlock richer job and client details **at no extra cost**.
- ⚙️ **Still Flexible** – Advanced filters, raw URL support, and custom rules let you shape the exact feed you want.

> **Already live**: These protections and automatic authentication are active for all runs — you don't need to change anything to benefit.

### What's New (Latest Update)

Great news! We've rolled out a significant upgrade to the Upwork Scraper that makes your life easier and your data richer.

#### 🔑 Automatic In‑House Cookies

- ✅ **Automatic Authentication** – You now get fully authenticated results by default.  
- ✅ **Zero Setup Required** – No need to provide your own cookies anymore.  
- ✅ **Richer Data** – Access to more job details and client information.  
- ✅ **Lower Ban Risk** – Our rotating in‑house cookie system keeps you safe.  
- ✅ **Same Price** – All these benefits at no additional cost.  

This feature is already active on your account. The next time you run the scraper, you'll automatically benefit from:

- More comprehensive job details
- Enhanced client statistics
- Better data quality
- Improved reliability

#### Still Want to Use Your Own Cookies?

No problem! You can still provide your own cookies in the input if you prefer. The scraper will use them instead of our in‑house system.

---

### Core Features
- **Customizable Searches**: Enter specific keywords, categories, budget ranges, and other criteria to tailor your job search.
- **Flexible Filtering Options**: Filter jobs by experience level, job type (hourly or fixed-price), budget ranges, client history, and location.
- **Advanced Custom Filters**: Apply custom filters to any job property using conditions like "includes", "equals", "notIncludes", and "notEquals".
- **Job Age Filtering**: Filter out jobs older than a specific time threshold (minutes, hours, days, or weeks).
- **Location-Based Filtering**: Target jobs by regions, subregions, or specific countries worldwide.
- **Raw URL Support**: Directly use specific Upwork search URLs instead of constructing them from parameters.
- **Automatic Authentication (In‑House Cookies)**: Managed cookie pool for authenticated sessions without requiring your own cookies.
- **Automatic Proxies & CAPTCHA Solving**: Built‑in proxy rotation and CAPTCHA bypass keep runs stable and resilient.
- **Detailed Information Extraction**: Pulls comprehensive job information including title, description, client statistics, budget details, required skills, and posting time.
- **Modern Architecture**: Built with TypeScript and Node.js for reliability and maintainability.
- **Cloudflare / Protection Bypass**: Advanced techniques to reliably access Upwork job data.
- **Case-Insensitive Matching**: All filtering is case-insensitive for more intuitive search experiences.

### Use Cases
- **Targeted Job Hunting**: Find exactly the kind of projects you're qualified for without spending hours manually searching.
- **Market Research**: Understand what services are in demand and how much clients are willing to pay for different skills.
- **Competitive Analysis**: Track which skills are most requested in your field to guide your professional development.
- **Opportunity Alerts**: Stay updated with the latest job postings that match your skill set without the need for constant manual searching.
- **Fresh Job Alerts**: Focus only on recent job postings by filtering out older listings.
- **Complex Search Criteria**: Combine multiple filter conditions to find highly specific job matches.

### How to Use
Getting started with the Upwork Job Listings Scraper is easy:

1. **Set Your Parameters**: 
  - Enter your search query (optional if raw URL provided)
  - Provide a raw Upwork search URL (optional, overrides other search parameters)
  - Set maximum job age to filter out older jobs (e.g., 24 hours, 3 days)
  - Define custom filters for precise job matching
  - Choose which page to start from (default: 1)
  - Set results per page (default: 10)
  - Select sorting order (newest or relevance)
  - Filter by experience level (entry, intermediate, expert)
  - Specify job type (fixed or hourly)
  - Set budget ranges for both fixed and hourly jobs
  - Filter by client hiring history
  - Filter by location (regions, subregions, or countries)
  - **(Optional)** Provide your own authentication cookies if you want to override the in‑house system.

2. **Run the Scraper**: Launch the scraper and let it gather the job listings for you. Automatic cookies, proxies, and CAPTCHA solving are applied behind the scenes.

3. **Analyze the Results**: Review the detailed job data to find the perfect opportunities.

### Minimum Billing Per Run

Each run has a **minimum billable size of 10 jobs**. Every run incurs fixed costs for CAPTCHA solving, proxy rotation, and request processing regardless of how many jobs match your filters, so a minimum of 10 jobs is billed per run even if fewer results are returned.

### Free-Tier Limits

- Non-paying Apify users are limited to 10 total runs and 100 total results across all runs.
- A free-user run counts when the scrape starts, even if it returns zero matching jobs.
- Once either free-tier quota is exhausted, the actor exits cleanly and tells the user to get an Apify paid plan to continue.

### Output Format
After each run, the scraper generates a dataset of Upwork jobs with the following information:

- **Job ID and URL**: Unique identifiers and direct links to job listings
- **Title and Description**: Detailed information about what the job entails
- **Budget Information**: Fixed price amount or hourly rate ranges
- **Client Statistics**: Total spent, number of hires, feedback scores, etc.
- **Job Requirements**: Experience level, skills needed, and category
- **Posting Time**: When the job was published
- **Additional Details**: Tags, contract type, engagement duration, and more

### Supported Filtering Options

#### Standard Filters
- **Experience Levels**: Entry Level, Intermediate, Expert
- **Job Types**: Fixed Price, Hourly Rate
- **Client History**: No previous hires, 1-9 previous hires, 10+ previous hires
- **Maximum Job Age**: Filter by minutes, hours, days, or weeks
- **Locations**: Filter by regions, subregions, or specific countries
- **Payment Verification**: Filter jobs by whether the client has verified payment methods

  **Example Maximum Job Age Filter**:
  ```json
  {
    "value": 24,
    "unit": "hours"
  }
````

This example would filter out jobs older than 24 hours. Supported units are "minutes", "hours", "days", and "weeks".

**Example Location Filter**:

```json
["United States", "Europe", "Australia"]
```

This example would filter jobs to only show those from the United States, Europe, and Australia regions.

#### Custom Filters

Custom filters allow you to filter jobs based on any job property:

- **Available Properties**:
  - title
  - description
  - jobType
  - experienceLevel
  - budget
  - tags
  - relativeDate
  - absoluteDate
  - paymentVerified
  - clientLocation
  - allowedApplicantCountries

- **Available Operators**:
  - includes - checks if the value is included in the property (supports both single string and array of strings)
  - equals - checks if the value exactly matches the property
  - notIncludes - checks if the value is not included in the property (supports both single string and array of strings)
  - notEquals - checks if the value does not exactly match the property

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

- **Example Using Arrays with Includes Operator**:
  ```json
  [
    {
      "key": "title",
      "operator": "includes",
      "value": ["react", "vue", "angular"]
    },
    {
      "key": "description",
      "operator": "includes",
      "value": ["typescript", "javascript"]
    }
  ]
  ```
  This example will find jobs that have any of "react", "vue", or "angular" in the title AND have either "typescript" or "javascript" in the description. Using arrays with the includes operator allows you to efficiently search for multiple terms without creating separate filters for each term.

### Filtering Jobs by Eligible Countries

One of the most powerful features of this scraper is the ability to filter jobs based on which countries are eligible to apply. The `allowedApplicantCountries` property contains an array of country names that the client has explicitly restricted the job to - meaning **only** applicants from these countries are allowed to apply, and applicants from all other countries are excluded.

#### Using the allowedApplicantCountries Filter

To find jobs that specifically allow applicants from your country (and exclude those that don't):

```json
[
  {
    "key": "allowedApplicantCountries",
    "operator": "includes",
    "value": "United States"
  }
]
```

This example will only show jobs that explicitly allow applicants from the United States. Jobs that don't include the United States in their allowed countries list will be filtered out.

#### Finding Jobs Open to Multiple Specific Countries

You can search for jobs that allow applicants from any of several countries using an array:

```json
[
  {
    "key": "allowedApplicantCountries",
    "operator": "includes",
    "value": ["United States", "United Kingdom"]
  }
]
```

This example will show jobs that allow applicants from either the United States OR the United Kingdom (or both). The job must allow at least one of these countries to be included in the results.

#### Finding Jobs Open to All Countries

To find jobs that are open to applicants from all countries (no country restrictions):

```json
[
  {
    "key": "allowedApplicantCountries",
    "operator": "equals",
    "value": null
  }
]
```

When a job has no country restrictions (allowedApplicantCountries is null), it means the job is open to applicants from any country.

### Using Authentication Cookies (Optional)

You **do not** need to provide cookies anymore – the scraper uses in‑house cookies automatically.

However, if you prefer to use your own Upwork cookies (for example, to see results exactly as a specific account), you still can.

#### Required Cookies

If you decide to override the in‑house cookies, provide at least these two from your logged‑in Upwork session:

- `master_access_token`
- `oauth2_global_js_token`

#### Cookies Format

Provide cookies as an array of objects with this structure:

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

Only the `name` and `value` fields are required; the others are handled automatically.

#### Example

```json
{
  "query": "web scraping",
  "cookies": [
    {
      "name": "master_access_token",
      "value": "ABC123XYZ"
    },
    {
      "name": "oauth2_global_js_token",
      "value": "def456uvw"
    }
  ]
}
```

### Supported Regions and Countries Search

The scraper supports filtering jobs from various regions and countries:

#### Regions

- Africa
- Americas
- Antarctica
- Asia
- Europe
- Oceania

#### Subregions

- Australia and New Zealand
- Caribbean
- Central America
- Central Asia
- Eastern Africa
- Eastern Asia
- Eastern Europe
- Melanesia
- Micronesia
- Middle Africa
- Northern Africa
- Northern America
- Northern Europe
- Polynesia
- South America
- South-Eastern Asia
- Southern Africa
- Southern Asia
- Southern Europe
- Western Africa
- Western Asia
- Western Europe

#### Countries

- Albania
- Algeria
- American Samoa
- Andorra
- Angola
- Anguilla
- Antigua and Barbuda
- Argentina
- Armenia
- Aruba
- Australia
- Austria
- Azerbaijan
- Bahamas
- Bahrain
- Bangladesh
- Barbados
- Belgium
- Belize
- Benin
- Bermuda
- Bhutan
- Bolivia
- Bonaire, Sint Eustatius and Saba
- Bosnia and Herzegovina
- Botswana
- Bouvet Island
- Brazil
- British Indian Ocean Territory
- British Virgin Islands
- Brunei Darussalam
- Bulgaria
- Burkina Faso
- Burundi
- Cambodia
- Cameroon
- Canada
- Cape Verde
- Cayman Islands
- Central African Republic
- Chad
- Chile
- China
- Christmas Island
- Cocos (Keeling) Islands
- Colombia
- Comoros
- Congo
- Congo, the Democratic Republic of the
- Cook Islands
- Costa Rica
- Cote d'Ivoire
- Croatia
- Curacao
- Cyprus
- Czech Republic
- Denmark
- Djibouti
- Dominica
- Dominican Republic
- Ecuador
- Egypt
- El Salvador
- Equatorial Guinea
- Eritrea
- Estonia
- Ethiopia
- Falkland Islands
- Faroe Islands
- Fiji
- Finland
- France
- French Guiana
- French Polynesia
- French Southern and Antarctic Lands
- Gabon
- Gambia
- Georgia
- Germany
- Ghana
- Gibraltar
- Greece
- Greenland
- Grenada
- Guadeloupe
- Guam
- Guatemala
- Guernsey
- Guinea
- Guinea-Bissau
- Guyana
- Haiti
- Heard Island and McDonald Islands
- Holy See
- Honduras
- Hong Kong
- Hungary
- Iceland
- India
- Indonesia
- Ireland
- Isle of Man
- Israel
- Italy
- Jamaica
- Japan
- Jersey
- Jordan
- Kazakhstan
- Kenya
- Kiribati
- Kuwait
- Kyrgyzstan
- Laos
- Latvia
- Lebanon
- Lesotho
- Liechtenstein
- Lithuania
- Luxembourg
- Macao
- Macedonia
- Madagascar
- Malawi
- Malaysia
- Maldives
- Mali
- Malta
- Marshall Islands
- Martinique
- Mauritania
- Mauritius
- Mayotte
- Mexico
- Micronesia, Federated States of
- Moldova
- Monaco
- Mongolia
- Montenegro
- Montserrat
- Morocco
- Mozambique
- Myanmar
- Namibia
- Nauru
- Nepal
- Netherlands
- Netherlands Antilles
- New Caledonia
- New Zealand
- Nicaragua
- Niger
- Nigeria
- Niue
- Norfolk Island
- Northern Mariana Islands
- Norway
- Oman
- Pakistan
- Palau
- Palestinian Territories
- Panama
- Papua New Guinea
- Paraguay
- Peru
- Philippines
- Pitcairn
- Poland
- Portugal
- Puerto Rico
- Qatar
- Reunion
- Romania
- Rwanda
- Saint Barthelemy
- Saint Helena
- Saint Kitts and Nevis
- Saint Lucia
- Saint Martin (French part)
- Saint Pierre and Miquelon
- Saint Vincent and the Grenadines
- Samoa
- San Marino
- Sao Tome and Principe
- Saudi Arabia
- Senegal
- Serbia
- Seychelles
- Sierra Leone
- Singapore
- Sint Maarten (Dutch part)
- Slovakia
- Slovenia
- Solomon Islands
- Somalia
- South Africa
- South Korea
- Spain
- Sri Lanka
- Suriname
- Svalbard and Jan Mayen
- Swaziland
- Sweden
- Switzerland
- Taiwan
- Tajikistan
- Tanzania
- Thailand
- Timor-Leste
- Togo
- Tokelau
- Tonga
- Trinidad and Tobago
- Tunisia
- Turkey
- Turkmenistan
- Turks and Caicos Islands
- Tuvalu
- Uganda
- Ukraine
- United Arab Emirates
- United Kingdom
- United States
- United States Minor Outlying Islands
- United States Virgin Islands
- Uruguay
- Uzbekistan
- Vanuatu
- Venezuela
- Vietnam
- Wallis and Futuna
- Western Sahara
- Yemen
- Zambia
- Zimbabwe

> **Note**: For locations with spaces, enter them exactly as they appear. In the URL, spaces will be encoded as `%2520`.

# Actor input Schema

## `query` (type: `string`):

Keywords to search for in Upwork jobs

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

Directly use this Upwork search URL instead of constructing one (must be from upwork.com and include nx/search/jobs)

## `experienceLevel` (type: `array`):

Filter jobs by required experience level

## `jobType` (type: `array`):

Filter jobs by payment type

## `paymentVerified` (type: `boolean`):

Filter jobs by payment verification status

## `fixedPriceRange` (type: `array`):

Range for fixed-price jobs (min and max in USD, e.g. \[100, 1000])

## `hourlyRateRange` (type: `array`):

Range for hourly rate jobs (min and max in USD/hour, e.g. \[20, 50])

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

Filter by client hiring history

## `location` (type: `array`):

Filter jobs by location (regions, subregions, or countries)

## `cookies` (type: `array`):

Cookies to use for requests (useful for bypassing Upwork's protection)

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

Custom filters to apply to job results

## `page` (type: `integer`):

Page number to start scraping from

## `pagesToScrape` (type: `integer`):

Number of pages to scrape sequentially starting from the specified page. Non-paying Apify users are limited to 5 total runs and 500 total results across all runs.

## `perPage` (type: `integer`):

Number of results to display per page

## `sort` (type: `string`):

How to sort the job listings

## `maxJobAge` (type: `object`):

Filter out jobs older than this time

## Actor input object example

```json
{
  "query": "web scraping",
  "experienceLevel": [
    "entry",
    "intermediate"
  ],
  "jobType": [
    "fixed"
  ],
  "paymentVerified": true,
  "fixedPriceRange": [
    "100",
    "1000"
  ],
  "hourlyRateRange": [
    "20",
    "50"
  ],
  "clientHistory": [
    "1to9Hires",
    "10+Hires"
  ],
  "location": [
    "United States",
    "Europe"
  ],
  "cookies": [
    {
      "name": "master_access_token",
      "value": "your-cookie-value-here"
    },
    {
      "name": "oauth2_global_js_token",
      "value": "another-cookie-value"
    }
  ],
  "customFilters": [
    {
      "key": "title",
      "operator": "includes",
      "value": "python"
    },
    {
      "key": "experienceLevel",
      "operator": "equals",
      "value": "Expert"
    },
    {
      "key": "jobType",
      "operator": "equals",
      "value": "Hourly"
    },
    {
      "key": "tags",
      "operator": "notIncludes",
      "value": "wordpress"
    }
  ],
  "page": 1,
  "pagesToScrape": 1,
  "perPage": 50,
  "sort": "newest",
  "maxJobAge": {
    "value": 24,
    "unit": "hours"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `resultsCompact` (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 = {
    "query": "web scraping",
    "experienceLevel": [
        "entry",
        "intermediate",
        "expert"
    ],
    "jobType": [
        "fixed",
        "hourly"
    ],
    "clientHistory": [
        "noHires",
        "1to9Hires",
        "10+Hires"
    ],
    "cookies": [],
    "customFilters": [],
    "maxJobAge": {
        "value": 24,
        "unit": "hours"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("neatrat/upwork-job-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 = {
    "query": "web scraping",
    "experienceLevel": [
        "entry",
        "intermediate",
        "expert",
    ],
    "jobType": [
        "fixed",
        "hourly",
    ],
    "clientHistory": [
        "noHires",
        "1to9Hires",
        "10+Hires",
    ],
    "cookies": [],
    "customFilters": [],
    "maxJobAge": {
        "value": 24,
        "unit": "hours",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("neatrat/upwork-job-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 '{
  "query": "web scraping",
  "experienceLevel": [
    "entry",
    "intermediate",
    "expert"
  ],
  "jobType": [
    "fixed",
    "hourly"
  ],
  "clientHistory": [
    "noHires",
    "1to9Hires",
    "10+Hires"
  ],
  "cookies": [],
  "customFilters": [],
  "maxJobAge": {
    "value": 24,
    "unit": "hours"
  }
}' |
apify call neatrat/upwork-job-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Upwork Job Scraper",
        "description": "Scrape Upwork jobs without limits 🌟 Bypass CAPTCHAs & apply custom filters.\n\nApify is retiring rental Actors, so pricing is changing. For many users around ~7k jobs/month, cost should stay near the old $25. You still get the same no-cookie setup, with in-house Upwork accounts and proxies built in.",
        "version": "0.0",
        "x-build-id": "CgCkjrlCk8W86CVSe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/neatrat~upwork-job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-neatrat-upwork-job-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/neatrat~upwork-job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-neatrat-upwork-job-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/neatrat~upwork-job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-neatrat-upwork-job-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": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keywords to search for in Upwork jobs"
                    },
                    "rawUrl": {
                        "title": "Raw URL",
                        "type": "string",
                        "description": "Directly use this Upwork search URL instead of constructing one (must be from upwork.com and include nx/search/jobs)"
                    },
                    "experienceLevel": {
                        "title": "Experience Level",
                        "type": "array",
                        "description": "Filter jobs by required experience level",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobType": {
                        "title": "Job Type",
                        "type": "array",
                        "description": "Filter jobs by payment type",
                        "items": {
                            "type": "string"
                        }
                    },
                    "paymentVerified": {
                        "title": "Payment Verified",
                        "type": "boolean",
                        "description": "Filter jobs by payment verification status"
                    },
                    "fixedPriceRange": {
                        "title": "Fixed Price Range",
                        "minItems": 2,
                        "maxItems": 2,
                        "type": "array",
                        "description": "Range for fixed-price jobs (min and max in USD, e.g. [100, 1000])",
                        "items": {
                            "type": "string"
                        }
                    },
                    "hourlyRateRange": {
                        "title": "Hourly Rate Range",
                        "minItems": 2,
                        "maxItems": 2,
                        "type": "array",
                        "description": "Range for hourly rate jobs (min and max in USD/hour, e.g. [20, 50])",
                        "items": {
                            "type": "string"
                        }
                    },
                    "clientHistory": {
                        "title": "Client History",
                        "type": "array",
                        "description": "Filter by client hiring history",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "array",
                        "description": "Filter jobs by location (regions, subregions, or countries)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cookies": {
                        "title": "Cookies",
                        "type": "array",
                        "description": "Cookies to use for requests (useful for bypassing Upwork's protection)"
                    },
                    "customFilters": {
                        "title": "Custom Filters",
                        "type": "array",
                        "description": "Custom filters to apply to job results"
                    },
                    "page": {
                        "title": "Page Number",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Page number to start scraping from",
                        "default": 1
                    },
                    "pagesToScrape": {
                        "title": "Pages to Scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Number of pages to scrape sequentially starting from the specified page. Non-paying Apify users are limited to 5 total runs and 500 total results across all runs.",
                        "default": 1
                    },
                    "perPage": {
                        "title": "Results Per Page",
                        "minimum": 10,
                        "type": "integer",
                        "description": "Number of results to display per page",
                        "default": 50
                    },
                    "sort": {
                        "title": "Sort Order",
                        "enum": [
                            "newest",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "How to sort the job listings",
                        "default": "newest"
                    },
                    "maxJobAge": {
                        "title": "Maximum Job Age",
                        "type": "object",
                        "description": "Filter out jobs older than this time"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
