# Upwork Jobs Finder (`deepmine/upwork-jobs-finder`) Actor

Upwork Jobs Finder scrapes Upwork job listings by keyword and exports structured freelance job data, including title, budget, hourly rate, skills, and description. Ideal for Upwork lead generation, job monitoring, market research, and automation workflows.

- **URL**: https://apify.com/deepmine/upwork-jobs-finder.md
- **Developed by:** [DeepMine](https://apify.com/deepmine) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 13 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period. You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#rental-actors

## 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 Jobs Finder

Upwork Jobs Finder is an Upwork job scraper for discovering freelance jobs by keyword and exporting clean, structured job data for lead generation, market research, and job monitoring automation.

This actor is built for teams that need reliable **Upwork jobs data** without manual browsing, copy/paste, or fragile one-off scripts.

### Why Use This Upwork Scraper

- Scrape Upwork job listings by keyword, niche, role, or service.
- Track newly posted freelance jobs in high-value categories.
- Build targeted lead lists for agencies and freelancers.
- Monitor Upwork demand by skill, budget, and experience level.
- Export structured JSON data for CRMs, dashboards, and automations.

If you need an **Upwork jobs API-style output**, this actor provides production-ready dataset records that are easy to consume in Make, Zapier, n8n, Airtable, Google Sheets, and custom backends.

### Core Features

- Keyword-based Upwork job search scraping.
- Multi-query runs in one execution.
- Filters for:
  - Job type (`all`, `fixed`, `hourly`)
  - Experience level (`any`, `entry-level`, `intermediate`, `expert`)
  - Sort mode (`recency`, `relevance`)
- Optional deeper job detail scraping for richer records.
- Structured output with normalized fields for downstream processing.
- Proxy configuration support for scalable runs.

### Typical Use Cases

- Freelance lead generation on Upwork.
- Upwork proposal pipeline automation.
- Upwork market intelligence by category or skill.
- Competitor monitoring of posted freelance demand.
- Trend analysis for rates, budgets, and hiring patterns.
- Building niche job alerts for VA teams and recruiters.

### Input

#### Required

- `searchQueries` (array of strings)
  - Example: `["javascript developer", "python scraping", "shopify developer"]`

#### Key Optional Parameters

- `maxJobsPerQuery` (integer)
- `sort` (`recency` or `relevance`)
- `jobType` (`all`, `fixed`, `hourly`)
- `experienceLevel` (`any`, `entry-level`, `intermediate`, `expert`)
- `scrapeJobDetails` (boolean)
- `proxyConfiguration` (Apify proxy object)

#### Reliability and Performance Controls

- `navigationRetries`
- `navigationTimeoutSeconds`
- `challengeWaitSeconds`
- `queryTimeCapSeconds`
- `stopAfterFirstBlockedQuery`

These controls let you tune speed, cost, and stability for your use case.

### Output Data

Each dataset item contains normalized job listing data and, when enabled, additional detail-page fields.

#### Main Fields

- `searchQuery`
- `jobId`
- `title`
- `url`
- `postedAge`
- `jobType`
- `experienceLevel`
- `budget`
- `hourlyRate`
- `description`
- `skills`

#### Optional Detail Fields (when `scrapeJobDetails=true`)

- `fullDescription`
- `locationRestriction`
- `projectType`
- `attributes`
- `proposals`
- `lastViewed`
- `hires`
- `interviewing`
- `invitesSent`
- `client.memberSince`
- `client.country`
- `client.totalSpent`
- `client.totalHires`

#### Example Output

```json
{
  "searchQuery": "python scraping",
  "jobId": "2030313017716519876",
  "title": "Need Python Scraper for Ecommerce Data",
  "url": "https://www.upwork.com/jobs/~2030313017716519876",
  "postedAge": "3 hours ago",
  "jobType": "Hourly",
  "experienceLevel": "Expert",
  "budget": null,
  "hourlyRate": "$40.00 - $70.00",
  "description": "Looking for an experienced Python developer to scrape product and pricing data...",
  "skills": ["Python", "Web Scraping", "Data Extraction"]
}
```

### SEO Keywords This Actor Targets

Upwork scraper, Upwork jobs scraper, scrape Upwork jobs, Upwork jobs API, Upwork freelance jobs data, Upwork lead generation, Upwork job monitoring, Upwork data extraction, Upwork job listings scraper, freelance job scraping, Upwork automation, Upwork market research.

### How To Run

#### On Apify Console

1. Open the actor input.
2. Add one or more `searchQueries`.
3. Set `maxJobsPerQuery` and filters.
4. Run the actor.
5. Download results from the dataset in JSON, CSV, Excel, XML, or RSS.

#### Via Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/<ACTOR_ID>/runs?token=<APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["javascript developer", "python scraping"],
    "maxJobsPerQuery": 100,
    "sort": "recency",
    "jobType": "all",
    "experienceLevel": "any",
    "scrapeJobDetails": false
  }'
```

Then fetch dataset items from the run output.

### Tips For Better Results

- Use focused, high-intent queries such as:
  - `"shopify conversion rate optimization"`
  - `"cold email copywriter"`
  - `"amazon ppc manager"`
- Run multiple niche queries in one actor run.
- Increase `maxJobsPerQuery` for broader lead lists.
- Enable detail scraping only when you need deeper client/activity fields.

### FAQ

#### Can I use this as an Upwork jobs feed for automations?

Yes. The actor outputs structured dataset records that work well with webhook/API automations.

#### Can I monitor multiple niches at once?

Yes. Add multiple entries to `searchQueries` and the actor will process them in one run.

#### Is this useful for agencies and freelance lead gen teams?

Yes. This actor is designed for scalable **Upwork lead generation** and repeatable prospecting workflows.

#### Does it return structured fields for analysis?

Yes. Core job fields are normalized for filtering, ranking, scoring, and dashboarding.

### Changelog-Ready Positioning

This actor is continuously optimized for practical Upwork scraping workflows: better field consistency, cleaner output normalization, and production-focused controls for cost and reliability.

# Actor input Schema

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

Keywords to search for on Upwork. Add one per line — each query is scraped independently.

## `maxJobsPerQuery` (type: `integer`):

Maximum number of job listings to collect per search query.

## `maxPagesPerQuery` (type: `integer`):

Optional hard limit for pagination depth per query. Leave empty for no page cap.

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

Sort search results by recency or relevance.

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

Filter by fixed-price or hourly jobs, or return all.

## `experienceLevel` (type: `string`):

Filter by required experience level.

## `enforceQueryRelevance` (type: `boolean`):

Apply stricter token-level filtering so each returned job matches all query keywords (recommended for stable, precise results).

## `scrapeJobDetails` (type: `boolean`):

Visit each job's individual page to collect full description, proposal activity, client history, and location restrictions. Slower but more complete — roughly doubles run time.

## `stealthMode` (type: `boolean`):

Enable anti-detection browser hardening and challenge-resilient navigation behavior.

## `enableHumanCursor` (type: `boolean`):

Enable human-like cursor movement for checkbox-based verification challenges.

## `humanizeMaxTimeSec` (type: `number`):

Maximum cursor movement duration in seconds for humanized pointer movement.

## `disableCoop` (type: `boolean`):

Disables Cross-Origin-Opener-Policy handling to allow cross-origin iframe interaction. Keep OFF unless needed for specific challenge pages.

## `stopAfterFirstBlockedQuery` (type: `boolean`):

If the first query is fully challenge-blocked and returns zero jobs, stop the run early to reduce usage. Turn off to continue remaining queries.

## `navigationRetries` (type: `integer`):

How many times to rotate session and retry when challenge or navigation failures happen.

## `navigationTimeoutSeconds` (type: `integer`):

Timeout for a single page navigation attempt.

## `challengeWaitSeconds` (type: `integer`):

How long to keep waiting on anti-bot challenge pages before rotating session.

## `queryTimeCapSeconds` (type: `integer`):

Maximum total time spent per query before returning partial results.

## `persistSessionState` (type: `boolean`):

Reuse cookies/storage across runs for a sticky Upwork session cohort and better result consistency.

## `proxyConfiguration` (type: `object`):

Residential proxies are recommended — Upwork blocks datacenter IPs.

## `proxySessionId` (type: `string`):

Set a fixed proxy session ID to improve run-to-run consistency by reusing the same proxy cohort.

## Actor input object example

```json
{
  "searchQueries": [
    "vibe code"
  ],
  "maxJobsPerQuery": 50,
  "sort": "recency",
  "jobType": "all",
  "experienceLevel": "any",
  "enforceQueryRelevance": true,
  "scrapeJobDetails": false,
  "stealthMode": true,
  "enableHumanCursor": true,
  "humanizeMaxTimeSec": 1.5,
  "disableCoop": false,
  "stopAfterFirstBlockedQuery": false,
  "navigationRetries": 3,
  "navigationTimeoutSeconds": 35,
  "challengeWaitSeconds": 25,
  "queryTimeCapSeconds": 180,
  "persistSessionState": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "proxySessionId": "upwork-stable"
}
```

# Actor output Schema

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

No description

## `jobs` (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 = {
    "searchQueries": [
        "vibe code"
    ],
    "proxySessionId": "upwork-stable"
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/upwork-jobs-finder").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["vibe code"],
    "proxySessionId": "upwork-stable",
}

# Run the Actor and wait for it to finish
run = client.actor("deepmine/upwork-jobs-finder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "vibe code"
  ],
  "proxySessionId": "upwork-stable"
}' |
apify call deepmine/upwork-jobs-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deepmine/upwork-jobs-finder"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/XKTgZjat58oUAWdGf/builds/gBsp3vnAUEroiRec0/openapi.json