# Upwork Job Scanner (`snipework/upwork-job-scanner`) Actor

Fresh Upwork jobs, pre-scanned every 2 minutes. Filter by category, keywords, budget and client country. Instant results, no login, no CAPTCHA. Powered by SnipeWork.

- **URL**: https://apify.com/snipework/upwork-job-scanner.md
- **Developed by:** [Serhii Dovhuy](https://apify.com/snipework) (community)
- **Categories:** Jobs, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 result delivereds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Scanner ⚡

**Fresh Upwork jobs, pre-scanned every 2 minutes.** Filter thousands of live freelance job postings by category, keywords, budget, contract type and client country — and get clean, structured JSON in seconds. No login, no cookies, no CAPTCHA, no browser spin-up.

Built and maintained by [SnipeWork](https://snipework.com) — an AI co-pilot for Upwork freelancers.

---

### Why this Actor is different

Most Upwork scrapers launch a browser on every run: they log in, solve CAPTCHAs, rotate proxies, and take 30–60 seconds before you see a single job. This one doesn't scrape on demand at all.

SnipeWork continuously scans Upwork on its own infrastructure and keeps a rolling 7-day pool of jobs, refreshed every ~2 minutes. This Actor reads straight from that pool, so:

- **Instant results.** No browser, no proxy warm-up — responses come back in milliseconds.
- **Zero ban risk for you.** Your account and IP are never involved.
- **Always up to date.** When Upwork changes its site, SnipeWork adapts on the backend — the Actor keeps working without updates.
- **Smart category filtering.** 100+ built-in categories with synonym expansion (say `react` and it also catches `next.js`, `nextjs`).
- **Incremental mode.** On a schedule, each run returns only jobs that appeared since the last run — so you never pay for the same job twice.

---

### What you can do with it

- Feed a personal job-alert pipeline (Slack, Discord, email, a Google Sheet).
- Build a freelance-market dataset for research or analytics.
- Power lead-gen for agencies watching specific niches or countries.
- Prototype your own freelance tool without building a scraper first.

---

### Input

| Field | Type | Description |
|---|---|---|
| `categories` | array | Include jobs matching at least one category (e.g. `react`, `web_development`, `logo_design`, `motion_graphics`, `wordpress`, `copywriting`, `seo`, `devops`). |
| `includeKeywords` | array | Keep only jobs whose title/description/skills contain at least one keyword. |
| `excludeKeywords` | array | Drop jobs containing any of these keywords. |
| `excludeTitleKeywords` | array | Drop jobs whose **title** contains any of these keywords. |
| `countries` | array | Only jobs from these client countries. |
| `jobType` | select | `all`, `fixed`, or `hourly`. |
| `minFixedPrice` | number | Minimum budget for fixed-price jobs. |
| `minHourlyRate` | number | Minimum rate for hourly jobs. |
| `maxAgeMinutes` | number | Only jobs first seen within N minutes (first run / full-snapshot mode). Max 7 days. |
| `maxItems` | number | Hard cap on jobs returned & billed per run (max 500). |
| `onlyNewSinceLastRun` | boolean | ON = only new jobs since last run (recommended for schedules). OFF = full snapshot within `maxAgeMinutes`. |

#### Example input

```json
{
  "categories": ["react", "frontend", "web_development"],
  "excludeKeywords": ["wordpress", "php"],
  "countries": ["United States", "United Kingdom"],
  "jobType": "hourly",
  "minHourlyRate": 30,
  "maxItems": 200,
  "onlyNewSinceLastRun": true
}
````

***

### Output

Each dataset item is one job:

```json
{
  "id": "~021ABC...",
  "title": "Senior React Developer for SaaS dashboard",
  "url": "https://www.upwork.com/jobs/~021ABC...",
  "description": "We are looking for...",
  "jobType": "hourly",
  "budget": "$30.00-$50.00",
  "skills": ["React", "TypeScript", "Next.js"],
  "category": "web_development",
  "country": "United States",
  "experienceLevel": "Expert",
  "duration": "More than 6 months",
  "postedAt": "12 minutes ago",
  "createdAt": "2026-07-15T09:41:00.000Z",
  "totalApplicants": 4,
  "client": {
    "totalSpent": 48200,
    "hires": 37,
    "jobsPosted": 52
  },
  "scannedAt": "2026-07-15T09:43:12.000Z"
}
```

***

### Pricing

This Actor uses **pay-per-event**:

- A small fixed charge per run.
- A per-result charge for each **new** job delivered to your dataset.

Because of incremental mode and client-side de-duplication, you're only billed for genuinely new jobs in your niche. A narrow niche on a twice-daily schedule typically costs a few dollars a month; pulling the entire market daily costs more because you get far more data. Set a **max cost per run** in the run options to cap spend precisely.

***

### Want alerts and AI proposals instead of raw data?

This Actor gives you the raw feed. If you're a freelancer who wants **instant Telegram alerts** the moment a matching job is posted, plus **AI-generated cover letters** tailored to each job and client, that's exactly what SnipeWork does:

👉 **[Try SnipeWork free for 14 days →](https://snipework.com)**

***

### Support

Questions, feature requests, or a category you'd like added? Open an issue on the Actor's **Issues** tab, or email **support@snipework.com**.

*Not affiliated with or endorsed by Upwork. "Upwork" is a trademark of its respective owner.*

# Actor input Schema

## `categories` (type: `array`):

Job categories to include. A job matches if it fits at least one category. Uses SnipeWork's 100+ category taxonomy (e.g. react, web\_development, logo\_design, motion\_graphics, wordpress, copywriting, seo, devops).

## `includeKeywords` (type: `array`):

A job matches only if its title/description/skills contain at least one of these keywords.

## `excludeKeywords` (type: `array`):

A job is dropped if its title/description/skills contain any of these keywords.

## `excludeTitleKeywords` (type: `array`):

A job is dropped if its TITLE contains any of these keywords.

## `countries` (type: `array`):

Only return jobs from these client countries. Leave empty for all countries.

## `jobType` (type: `string`):

Filter by contract type.

## `minFixedPrice` (type: `integer`):

Minimum budget for fixed-price jobs. Ignored for hourly jobs.

## `minHourlyRate` (type: `integer`):

Minimum rate for hourly jobs. Ignored for fixed-price jobs.

## `maxAgeMinutes` (type: `integer`):

Only return jobs first seen within this many minutes. Applies to the FIRST run or when 'Only new since last run' is off. Max 7 days (10080).

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

Hard cap on how many jobs this run returns (and is billed for). Combine with a per-run cost limit in the run options to fully control spend.

## `onlyNewSinceLastRun` (type: `boolean`):

When ON (recommended for schedules), each run returns ONLY jobs that appeared since the previous run — so you never pay twice for the same job. Turn OFF for a full snapshot within 'Max job age'.

## Actor input object example

```json
{
  "categories": [
    "react",
    "frontend",
    "web_development"
  ],
  "includeKeywords": [
    "nextjs",
    "typescript"
  ],
  "excludeKeywords": [
    "wordpress",
    "php"
  ],
  "excludeTitleKeywords": [
    "intern",
    "unpaid"
  ],
  "countries": [
    "United States",
    "United Kingdom",
    "Canada"
  ],
  "jobType": "all",
  "maxAgeMinutes": 1440,
  "maxItems": 200,
  "onlyNewSinceLastRun": true
}
```

# 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 = {
    "categories": [
        "react",
        "web_development"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("snipework/upwork-job-scanner").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 = { "categories": [
        "react",
        "web_development",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("snipework/upwork-job-scanner").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 '{
  "categories": [
    "react",
    "web_development"
  ]
}' |
apify call snipework/upwork-job-scanner --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Upwork Job Scanner",
        "description": "Fresh Upwork jobs, pre-scanned every 2 minutes. Filter by category, keywords, budget and client country. Instant results, no login, no CAPTCHA. Powered by SnipeWork.",
        "version": "0.1",
        "x-build-id": "w3X9gGdRXC8FhpyEj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/snipework~upwork-job-scanner/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-snipework-upwork-job-scanner",
                "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/snipework~upwork-job-scanner/runs": {
            "post": {
                "operationId": "runs-sync-snipework-upwork-job-scanner",
                "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/snipework~upwork-job-scanner/run-sync": {
            "post": {
                "operationId": "run-sync-snipework-upwork-job-scanner",
                "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": {
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Job categories to include. A job matches if it fits at least one category. Uses SnipeWork's 100+ category taxonomy (e.g. react, web_development, logo_design, motion_graphics, wordpress, copywriting, seo, devops).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeKeywords": {
                        "title": "Include keywords",
                        "type": "array",
                        "description": "A job matches only if its title/description/skills contain at least one of these keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeKeywords": {
                        "title": "Exclude keywords",
                        "type": "array",
                        "description": "A job is dropped if its title/description/skills contain any of these keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeTitleKeywords": {
                        "title": "Exclude title keywords",
                        "type": "array",
                        "description": "A job is dropped if its TITLE contains any of these keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Client countries",
                        "type": "array",
                        "description": "Only return jobs from these client countries. Leave empty for all countries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobType": {
                        "title": "Job type",
                        "enum": [
                            "all",
                            "fixed",
                            "hourly"
                        ],
                        "type": "string",
                        "description": "Filter by contract type.",
                        "default": "all"
                    },
                    "minFixedPrice": {
                        "title": "Min fixed-price budget ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum budget for fixed-price jobs. Ignored for hourly jobs."
                    },
                    "minHourlyRate": {
                        "title": "Min hourly rate ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum rate for hourly jobs. Ignored for fixed-price jobs."
                    },
                    "maxAgeMinutes": {
                        "title": "Max job age (minutes)",
                        "minimum": 1,
                        "maximum": 10080,
                        "type": "integer",
                        "description": "Only return jobs first seen within this many minutes. Applies to the FIRST run or when 'Only new since last run' is off. Max 7 days (10080).",
                        "default": 1440
                    },
                    "maxItems": {
                        "title": "Max results per run",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on how many jobs this run returns (and is billed for). Combine with a per-run cost limit in the run options to fully control spend.",
                        "default": 200
                    },
                    "onlyNewSinceLastRun": {
                        "title": "Only new since last run",
                        "type": "boolean",
                        "description": "When ON (recommended for schedules), each run returns ONLY jobs that appeared since the previous run — so you never pay twice for the same job. Turn OFF for a full snapshot within 'Max job age'.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
