# Upwork Jobs Scraper: New Jobs in 2 Minutes, Client Data (`alexmorain/upwork-jobs-scraper`) Actor

Upwork Jobs Scraper for real-time job alerts: new jobs 2 to 3 minutes after posting, with client country, spend, rating and exact proposals count. Keywords or search URLs, filters, new-jobs-only monitoring. No account.

- **URL**: https://apify.com/alexmorain/upwork-jobs-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Lead generation, Jobs, Automation
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 90.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 jobs

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Upwork Jobs Scraper do?

Upwork Jobs Scraper reads the job search of [Upwork](https://www.upwork.com) and gives you **new jobs 2 to 3 minutes after they are posted**, each with the client's country, total spend, rating, hires and the **exact number of proposals** already received. Give it keywords or paste an Upwork search URL, set filters, press Start. No Upwork account, no browser, no cookies to paste.

It works as an **Upwork jobs API**: plain HTTP requests to the guest search service that the Upwork search page itself calls. Turn on **New jobs only**, schedule the run every few minutes, and you have **real-time Upwork job alerts** that bill only the jobs you have not seen yet.

#### How fast do new jobs show up?

Upwork publishes a job, then its search index catches up. We measured the delay between a job's `publishTime` and the first time a poll saw it: **median 140 seconds, 90% under 175 seconds, slowest 248 seconds** (16 polls at 20 second intervals, 19 new jobs, 12 November 2026). A run that reads one page of the newest jobs takes 3 to 5 seconds and costs about $0.0005 to run, so polling every 2 to 5 minutes is cheap.

#### Past the 5,050 results wall of a single search

One Upwork search never lets you read past offset 5,000: the server answers `Paging offset greater than 5000`. A scraper that pages through one search therefore stops at 5,050 jobs, whatever the page says it holds. This actor cuts a big search into slices that do not overlap (the 12 Upwork categories, then job type, experience level and client history if a slice is still too big) and reads them all.

Measured on the Apify platform on 12 November 2026:

| Search | Announced by Upwork | One search (the most it lets you page through) | Upwork Jobs Scraper | Requests | Run time |
|---|---|---|---|---|---|
| "video" | 10,346 | 5,050 | **10,346**, no duplicates | 203 | 144 s |
| Same, run restarted by the platform in the middle | 10,346 | 5,050 | 10,345 distinct jobs (see the FAQ) | n/a | 198 s |

The 12 categories add up exactly to the whole market (94,196 open jobs that day), so a category slice never loses a job. Slicing by experience level can leave out the roughly 0.5% of jobs that have no experience level.

### Why use Upwork Jobs Scraper?

- **Freelancers and agencies.** Be among the first proposals on jobs that match your skills. Filter by budget, client country, hires and spend, and skip clients who never paid anyone.
- **Lead generation and sales.** Every Upwork job is a company with a need and a budget. Find who is hiring for *shopify developer*, *HubSpot*, *SEO audit* or *n8n*, and how much they spend.
- **Market research.** Count jobs per skill, compare fixed budgets and hourly rates by country, watch demand for a technology week after week.
- **Job boards and newsletters.** Feed a curated Upwork digest from a dataset, a Google Sheet, Slack or a webhook.
- **Pipelines.** Rows go to the dataset in JSON, CSV or Excel, to Google Sheets, Slack, Zapier, Make or n8n, and a webhook tells you when a run ends. Apify adds scheduling, an API for every run and monitoring.

### What data can Upwork Jobs Scraper extract?

Every row is one job.

| Field | Example | Description |
|---|---|---|
| `ciphertext`, `id`, `url` | `~022120995318862614544` | Stable job key (deduplicate on it), numeric id and link |
| `title`, `description` | `Scraping specialist who...` | Title and the complete description |
| `jobType` | `fixed` | `hourly` or `fixed` |
| `budget`, `budgetCurrency` | `150`, `USD` | Fixed-price budget |
| `hourlyRateMin`, `hourlyRateMax` | `20`, `40` | Hourly range |
| `experienceLevel` | `expert` | `entry`, `intermediate` or `expert` |
| `duration`, `durationWeeks`, `workload` | `1 to 3 months`, `9`, `part_time` | Expected length and hours per week |
| `skills` | `["Python", "Web Crawling"]` | Skills the client tagged |
| `publishedAt`, `createdAt` | `2026-11-12T21:42:38.710Z` | When the job went public and when it was started (UTC) |
| `search` | `python` | The keyword or URL that found it |

With **Read the job details** (or any client filter), each row also has:

| Field | Example | Description |
|---|---|---|
| `applicants` | `12` | Exact number of proposals so far, not a range |
| `interviewing`, `invitesSent`, `unansweredInvites`, `hires`, `positionsToHire` | `1`, `2`, `0`, `0`, `1` | What the client did with the proposals |
| `lastClientActivityAt` | `2026-11-12T22:10:00Z` | Last time the client was active on the job |
| `category`, `subcategory`, `occupation` | `Web, Mobile & Software Dev`, `Scripts & Utilities` | Where Upwork files the job |
| `clientCountry`, `clientCity`, `clientTimezone` | `United States`, `Austin` | Where the client is |
| `clientTotalSpent` | `7108.87` | Total the client has spent on Upwork, USD |
| `clientRating`, `clientReviews` | `4.99`, `14` | Feedback score and number of reviews |
| `clientHires`, `clientJobsWithHires`, `clientActiveContracts`, `clientHoursBilled` | `40`, `23`, `15`, `40.5` | Client history |
| `clientPaymentVerified`, `clientMemberSince` | `true`, `2024-05-01...` | Payment method and age of the account |
| `clientIndustry`, `clientCompanySize` | `Software`, `10` | Company profile when the client filled it in |
| `minJobSuccessScore`, `minHoursBilled`, `englishLevel`, `preferredCountries`, `requiresPortfolio`, `risingTalentOnly` | `90` | What the client asks of freelancers |
| `detailsFetched` | `true` | `false` when the details could not be read |

**Empty fields.** Upwork serves what it serves to a visitor, and the actor does not guess. `clientTotalSpent` is `null` for a client who never paid anyone (about 4 clients in 10), `clientRating` is `null` for a client with no feedback yet, and `clientIndustry` and `clientCompanySize` are often `null`. About **1 job in 10 is private**: Upwork asks for a login to show its details. Those rows keep every search field (title, description, budget, skills, dates) and have `detailsFetched: false` and empty client fields, and they are billed as a plain job. **With a client filter on** (maximum proposals, minimum spend, minimum rating, payment verified), a private job cannot be checked, so it is dropped, not delivered and not billed; the end-of-run message says how many private jobs were dropped and how many were delivered. The client's hire rate, the number of jobs they posted and their average hourly rate are not served to visitors and are not in the data.

### How to scrape Upwork jobs

1. Click **Try for free**.
2. Type one or more **Keywords** (one per line), or paste Upwork search URLs.
3. Pick filters if you want them: job type, experience level, budget, hourly rate, client country, client history, categories.
4. Tick **Read the job details** to get the client panel and the exact proposals count.
5. Set **Max jobs** and press **Start**. A 20-job run with details finishes in about 5 seconds.
6. Download the dataset as JSON, CSV or Excel, or send it on with an integration.

#### How to get Upwork job alerts every few minutes

1. Fill in your keywords and filters as above.
2. Turn on **New jobs only (monitoring)** and set **Only jobs published in the last N minutes** to `30`, so the first run does not return a month of jobs.
3. Add a **Webhook URL** (a Slack or Discord incoming webhook, a Zapier or Make URL).
4. In Apify, open **Schedules** and run the task every 2 to 5 minutes. Each run reads one page, skips the jobs it has seen and bills only the new ones.
5. In your tool, read the dataset of the run that the webhook names, or add an Apify integration that sends new rows to Slack, e-mail or a Google Sheet.

For a "be first" alert, add **Maximum proposals** `5` and a **Minimum client spend**: a job that fails the filter is not delivered and not billed.

### How much will it cost to scrape Upwork?

Pay per event, in dollars per 1,000, with volume discounts on the paid Apify plans (the price drops with your plan):

| Event | Free plan | Starter | Scale | Business and up |
|---|---|---|---|---|
| **Job** (search fields) | $1.00 | $0.90 | $0.70 | **$0.50** |
| **Job with detail** (client panel, exact proposals) | $1.50 | $1.30 | $1.10 | **$0.80** |
| Start of a run | $0.001 per GB of memory | same | same | same |

The default memory is 512 MB, so a run starts at **$0.001**. A job rejected by a client filter, a job already seen in New jobs only mode and a duplicate are never billed. A private job is billed as a plain job, unless a client filter drops it (then it is not billed).

Real examples, measured on the platform:

- **20 jobs with details**: about $0.03 at the free-plan price.
- **10,346 jobs of the search "video"**: about $10.35 at the free-plan price, $5.17 at the Business price.
- **A monitoring run every 3 minutes**: 480 runs a day, $0.48 a day for the starts plus the few new jobs each run finds.

Set **Max jobs** to cap a run, and Apify's own *maximum cost per run* option stops the run when your limit is reached.

### Input

See the **Input** tab for every option. The ones that need a word:

- **Keywords** and **Upwork search URLs** can be combined. The filters on the page (job type, level, budget...) apply to keywords. A pasted URL carries its own filters.
- **Fixed budget** only applies to fixed-price jobs and **Hourly rate** only to hourly jobs, so setting one limits the search to that type. Setting both runs two searches.
- **Categories** takes the 12 Upwork categories. With categories and no keyword you get every new job of those categories.
- **Maximum proposals**, **Minimum client spend**, **Minimum client rating** and **Payment verified clients only** are not offered by Upwork to a visitor, so the actor reads each job's details and applies them itself. Jobs that fail are not delivered and not billed.
- **Stop after this many rejected reads** (`maxRejectedReads`, default 2,000) is a safety net for the client filters. A job read and rejected is free for you but costs the actor a request, so a filter that nothing passes would read the whole market for nothing. The run stops, with a clear message in its status, when 2,000 jobs were rejected and they outnumber the delivered ones 20 to 1. Set `0` for no guard.
- **Max jobs** `0` means no limit. Above 5,050 the search is cut into slices (see above), so jobs do not come in strict date order.

```json
{
  "keywords": ["web scraping", "python scraper"],
  "jobType": "fixed",
  "minBudget": 500,
  "clientCountries": ["United States", "United Kingdom"],
  "maxApplicants": 5,
  "newOnly": true,
  "maxAgeMinutes": 30,
  "maxItems": 100
}
```

### Output

You can download the dataset in various formats such as JSON, HTML, CSV or Excel. A row with details:

```json
{
  "ciphertext": "~022120995318862614544",
  "url": "https://www.upwork.com/jobs/~022120995318862614544",
  "title": "Scraping specialist who has beaten Akamai bot protection",
  "jobType": "fixed",
  "budget": 150,
  "experienceLevel": "expert",
  "duration": "More than 6 months",
  "skills": ["Data Scraping", "Python", "Web Crawling", "Automation"],
  "publishedAt": "2026-11-12T21:42:38.710Z",
  "applicants": 4,
  "interviewing": 3,
  "clientCountry": "Rwanda",
  "clientPaymentVerified": true,
  "clientTotalSpent": 357,
  "clientRating": 4.97,
  "clientReviews": 13,
  "clientHires": 21,
  "detailsFetched": true,
  "search": "python scraper"
}
```

A private job keeps its search fields only:

```json
{
  "ciphertext": "~022120867209617137486",
  "title": "Looking for a developer",
  "jobType": "hourly",
  "hourlyRateMin": 20,
  "hourlyRateMax": 40,
  "publishedAt": "2026-11-12T20:11:00.000Z",
  "applicants": null,
  "clientCountry": null,
  "detailsFetched": false
}
```

#### Run it from Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("alexmorain/upwork-jobs-scraper").call(run_input={
    "keywords": ["n8n automation"],
    "includeDetails": True,
    "maxApplicants": 5,
    "maxAgeMinutes": 60,
    "maxItems": 50,
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], job["clientCountry"], job["applicants"], job["url"])
```

#### Run it from JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('alexmorain/upwork-jobs-scraper').call({
    keywords: ['shopify developer'],
    jobType: 'hourly',
    minHourlyRate: 40,
    maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'jobs');
```

#### Run it with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/alexmorain~upwork-jobs-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["web scraping"], "maxAgeMinutes": 30, "maxItems": 20}'
```

### Tips

- **Cheapest alert**: New jobs only, `maxAgeMinutes` of 30 to 60, no details. One page per run. Add details only on the filters that need them.
- **Be first**: `maxApplicants` 3 to 5 and a run every 2 minutes. Upwork lists a job about 2 to 3 minutes after the client posts it.
- **Search by skill or by exact phrase**: put quotes around a phrase, such as `"data entry"`.
- **Several clients in one go**: put several keywords. A job found by two keywords is delivered and billed once, and `search` tells you the first keyword that found it.
- **Big exports**: set Max jobs to `0` and a category, a job type or an experience level, so slices stay small and finish faster.

### FAQ, disclaimers and support

#### Can I get Upwork job alerts?

Yes, by polling. Turn on **New jobs only**, add a webhook URL and schedule the run in Apify every 2 to 5 minutes. A new job appears in the search about 2 to 3 minutes after it is posted (median 140 seconds in our measure), then your next run picks it up. There is no push from Upwork and no run faster than your schedule, so the delay you get is that of the search index plus your polling interval. See "How to get Upwork job alerts every few minutes" above.

#### How much does it cost?

$1.00 per 1,000 jobs, or $1.50 per 1,000 jobs with the client panel and exact proposals, on the free plan, down to $0.50 and $0.80 on the biggest plans, plus $0.001 per run start. Jobs you have already received in New jobs only mode, duplicates and jobs rejected by a client filter are not billed. The table above gives the exact prices and measured examples.

#### Which client data do I get?

Country, city, time zone, total spent, rating and number of reviews, hires, active contracts, payment verified, member since, industry and company size when the client filled them in. The client's name and contact details are not served to visitors and are not in the data. The hire rate, jobs posted and average hourly rate need a login and are not returned.

#### What are the limits?

No Upwork account, so private jobs (about 1 in 10) come with the search fields only. Upwork shows a visitor jobs 2 to 3 minutes after they are posted, not instantly. Past 5,050 results the search is cut into slices, so those jobs do not come in strict date order, and slicing by experience level can miss the roughly 0.5% of jobs with no level. Upwork limits requests per IP address, so very big runs take minutes. If Upwork changes its site, a run can fail until the actor is updated.

#### Do I need an Upwork account?

No. The actor reads what Upwork shows a visitor. It never logs in, so it cannot be tied to an Upwork account, and it cannot read what a login would add (the client's hire rate, number of jobs posted, proposal bids).

#### Why are some client fields empty?

See "Empty fields" above. The actor returns `null` rather than a guess: a client who never spent anything has no total, and a client with no feedback has no rating.

#### Can I get the freelancers' profiles or their bids?

No. The actor returns jobs and the client panel only. It does not read freelancer profiles.

#### Why did a restarted run bill a few jobs twice?

The platform can move a run to another machine, which restarts it. The actor remembers what it already delivered and skips it, but a batch of up to 50 jobs that was written just before the restart can be written again. We measured 50 repeated rows in 10,395 after a forced restart, and the `ciphertext` column tells you which. Billing follows the rows.

#### Why is my run slower than I expect on a big search?

Upwork refuses an IP address after roughly 130 to 145 requests in a few minutes. The actor changes IP address every 90 requests and as soon as Upwork answers "too many requests", so a big run keeps going, with a few retries visible in the log.

#### Is it legal?

Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

This actor returns job posts and the public profile of the hiring company (country, spend, rating), never a freelancer. Upwork's terms of use restrict automated access to the site and its `robots.txt` asks bots to stay out of its search interface. You are responsible for using the data in line with those terms and with the law where you are.

#### Support

Something missing, a field that came back empty on a job that has it, a feature you need? Open an issue on the **Issues** tab of the Actor page; it is read and answered. Everything on this page is also available through the **API** tab.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Upwork Jobs Scraper page](https://alexis.morain.fr/en/scrapers/upwork-jobs-scraper/) of my site. The [Job boards family page](https://alexis.morain.fr/en/scrapers/families/jobs/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

## `keywords` (type: `array`):

One search per line, such as <code>python</code>, <code>shopify developer</code> or <code>"data entry"</code>. Upwork searches titles, descriptions and skills. Jobs come newest first. Leave empty if you paste search URLs or pick categories below.

## `startUrls` (type: `array`):

Searches copied from your browser, one per line, such as <code>https://www.upwork.com/nx/search/jobs/?q=python\&t=1\&amount=500-999</code>. The keyword, job type, experience level, budget, hourly rate, client history, project length, hours per week, client location, category, payment verified and number of proposals filters are read from the URL. The sort order is always newest first. The filters below apply to keywords only, not to pasted URLs.

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

Hourly jobs have a rate range, fixed-price jobs a budget. A budget or hourly rate filter below sets this for you.

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

Entry level, intermediate or expert, as the client chose it. Several allowed.

## `minBudget` (type: `integer`):

Only fixed-price jobs with a budget of at least this amount. Setting a budget limits the search to fixed-price jobs.

## `maxBudget` (type: `integer`):

Only fixed-price jobs with a budget of at most this amount.

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

Only hourly jobs whose rate reaches at least this amount. Setting a rate limits the search to hourly jobs. With both a budget and a rate, the actor runs two searches.

## `maxHourlyRate` (type: `integer`):

Only hourly jobs paying at most this amount per hour.

## `clientCountries` (type: `array`):

Only jobs from clients located in these countries, written the way Upwork does: <code>United States</code>, <code>United Kingdom</code>, <code>Germany</code>. One per line.

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

How many freelancers the client already hired on Upwork. Handy to skip new clients, or to find the ones who never hired.

## `projectLength` (type: `array`):

Expected duration of hourly jobs.

## `hoursPerWeek` (type: `string`):

For hourly jobs.

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

The 12 Upwork categories. Several allowed. With no keyword, you get every new job of these categories.

## `contractToHire` (type: `boolean`):

Only jobs the client may turn into a full-time hire.

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

The cheap way to get alerts: <code>60</code> returns only the jobs published in the last hour, so a run every few minutes reads one page. Leave empty for no limit.

## `maxApplicants` (type: `integer`):

Only jobs with at most this many proposals so far, for example <code>5</code> to be among the first. Needs the job details: each job is read in full and billed as <b>job with details</b>. Jobs that fail the filter are not billed.

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

Needs the job details (billed as job with details; rejected jobs are not billed).

## `minClientSpent` (type: `number`):

Only clients who already spent at least this much on Upwork. A new client has no spend and is left out. Needs the job details (rejected jobs are not billed).

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

Only clients rated at least this (0 to 5). A client with no feedback yet is left out. Needs the job details (rejected jobs are not billed).

## `maxRejectedReads` (type: `integer`):

Safety net for the client filters (proposals, spend, rating, payment verified). Each job whose details were read and then rejected is free for you but costs a request. The run stops when this many jobs were rejected and they outnumber the delivered ones 20 to 1. <code>0</code> = no guard.

## `includeDetails` (type: `boolean`):

Adds the client panel (country, total spent, rating, hires, payment verified, member since) and the exact number of proposals, interviews and invites. Billed as <b>job with details</b>. About 1 job in 10 is private (Upwork asks for a login): it is delivered with the search fields only and billed as a plain <b>job</b>.

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

Stops the whole run after this many jobs. <code>0</code> = no limit: a broad search then returns everything Upwork holds, split into slices so the 5,050-result wall of a single search does not cut it.

## `newOnly` (type: `boolean`):

Delivers each job once: jobs a previous run of the same monitor already saw are skipped and never billed. Schedule the run every few minutes for alerts. The first run delivers what the search returns now (set <b>Max jobs</b> or the minutes limit to keep it small). Needs <b>Monitor name</b> if you run several monitors with the same searches.

## `registryKey` (type: `string`):

Names the list of jobs already seen. Empty = derived from your searches and filters, so the same input shares one list. Use a name to keep two monitors apart.

## `webhookUrl` (type: `string`):

POST of a JSON summary (run id, dataset id, jobs delivered, status) when the run ends. Slack and Discord incoming webhooks, Zapier and Make URLs work. The jobs themselves stay in the dataset.

## Actor input object example

```json
{
  "keywords": [
    "web scraping"
  ],
  "jobType": "any",
  "hoursPerWeek": "any",
  "contractToHire": false,
  "paymentVerifiedOnly": false,
  "maxRejectedReads": 2000,
  "includeDetails": true,
  "maxItems": 20,
  "newOnly": false
}
```

# Actor output Schema

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

One row per job

## `dataset` (type: `string`):

Every job with all fields

# 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 = {
    "keywords": [
        "web scraping"
    ],
    "includeDetails": true,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/upwork-jobs-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 = {
    "keywords": ["web scraping"],
    "includeDetails": True,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/upwork-jobs-scraper").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 '{
  "keywords": [
    "web scraping"
  ],
  "includeDetails": true,
  "maxItems": 20
}' |
apify call alexmorain/upwork-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

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/mWiYy2qNcPeag6Ne1/builds/tgDFmF4G38W8ZZtVu/openapi.json
