# Workana Freelance Projects Scraper (`automation-lab/workana-freelance-projects-scraper`) Actor

Search public Workana freelance projects and export budgets, skills, client locations, proposal counts, descriptions, and source URLs for opportunity monitoring.

- **URL**: https://apify.com/automation-lab/workana-freelance-projects-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.96 / 1,000 item extracteds

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?

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

## Workana Freelance Projects Scraper

Turn public **Workana freelance projects** into structured opportunity records for lead generation, scheduled monitoring, and labor-market analysis. Search by keyword, category, skill, client country, and page language, or extract a specific public project URL.

The Actor saves one project per dataset row with a stable URL and slug, budget, required skills, client location and payment signal, proposal count, publication age, and description. It does not require a Workana account.

### What can you do with this Workana scraper?

- Build a fresh feed of WordPress, design, marketing, writing, or programming opportunities.
- Monitor a niche on an Apify schedule and compare stable project IDs between runs.
- Segment public client demand by country, skills, budget, and proposal activity.
- Enrich a known Workana URL with its full public description and category.
- Export results to JSON, CSV, Excel, Google Sheets, webhooks, or your own data warehouse.

### Who is it for?

Freelancers and agencies can find relevant opportunities before repeatedly browsing the marketplace. Lead-generation teams can route matching projects into a CRM. Analysts can study skills, locations, budgets, and competition. Developers can consume a predictable dataset through the Apify API.

### What data is extracted?

| Field | Meaning |
| --- | --- |
| `projectId`, `url`, `title` | Stable project slug, canonical URL, and full title |
| `description` | Full detail-page description or search-card excerpt |
| `category`, `subcategory` | Workana slugs available on detail pages |
| `skills`, `skillSlugs` | Display names and reusable Workana skill filters |
| `budget`, `budgetCurrency` | Source text and detected currency |
| `budgetMin`, `budgetMax`, `isHourly` | Parsed budget bounds and billing unit |
| `clientName` | Public, often masked, client display name |
| `clientCountry`, `clientCountryCode` | Public location signal when shown |
| `clientPaymentVerified` | Visible payment-verification signal |
| `proposalCount` | Current bids/proposals shown by Workana |
| `publishedAtText`, `status` | Source publication text and visible status |
| `sourceType`, `searchUrl`, `scrapedAt` | Extraction provenance and timestamp |

Fields unavailable on the selected Workana surface are `null`; the Actor does not invent missing values.

### How to scrape Workana projects

1. Open the Actor input page.
2. Enter a `query`, such as `wordpress`, or choose a Workana category, skill, or client country.
3. Select `en`, `es`, or `pt` for Workana's displayed text.
4. Set `maxItems` and `maxPages` to bound the run.
5. Run the Actor and open the **Workana projects** dataset view.
6. Export the dataset or connect it to your workflow.

No filter is required: an empty search input returns current public projects.

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `query` | string | empty | Free-text Workana project search |
| `category` | string | empty | Category slug such as `it-programming` or `design-multimedia` |
| `skill` | string | empty | One skill slug such as `python` or `wordpress` |
| `country` | string | empty | Two-letter public client country code, for example `BR` |
| `locale` | enum | `en` | Workana page language: `en`, `es`, or `pt` |
| `projectUrls` | URL list | empty | Specific public `workana.com/job/...` pages |
| `maxItems` | integer | `50` | Unique project records to save, from 1 to 1,000 |
| `maxPages` | integer | `10` | Search pages to visit, from 1 to Workana's ceiling of 50 |
| `useProxy` | boolean | `false` | Use your Apify Proxy configuration instead of direct browser traffic |

`projectUrls` cannot be mixed with search filters. Keep exact-URL enrichment and filtered discovery in separate tasks so scope stays unambiguous.

### Search Workana by keyword

```json
{
  "query": "wordpress",
  "locale": "en",
  "maxItems": 20,
  "maxPages": 5
}
```

This is useful for a recurring niche opportunity feed. Schedule the same input and deduplicate downstream by `id` or `url`.

### Filter Workana projects by market

```json
{
  "category": "design-multimedia",
  "country": "BR",
  "locale": "pt",
  "maxItems": 25,
  "maxPages": 5
}
```

Use the source's own URL slugs. An invalid slug can legitimately return no records; start with a broad search and reuse a returned `skillSlugs` value.

### Extract a specific Workana project URL

```json
{
  "projectUrls": [
    { "url": "https://www.workana.com/job/desenvolvedor-full-stack-react-native-e-node-js-para-aplicativo-mobile" }
  ],
  "maxItems": 1
}
```

URL mode visits the project detail page and usually provides a fuller description and category context than search mode.

### Example output

```json
{
  "projectId": "development-of-a-simple-wordpress-website-with-10-screens",
  "url": "https://www.workana.com/job/development-of-a-simple-wordpress-website-with-10-screens",
  "title": "Development of a Simple Wordpress Website with 10 Screens",
  "description": "I need a freelancer to develop a very simple WordPress website...",
  "category": null,
  "subcategory": null,
  "skills": ["WordPress", "PHP", "HTML", "CSS", "JavaScript"],
  "skillSlugs": ["wordpress", "php", "html", "css", "javascript"],
  "budget": "USD 100 - 250",
  "budgetCurrency": "USD",
  "budgetMin": 100,
  "budgetMax": 250,
  "isHourly": false,
  "clientName": "Example C.",
  "clientCountry": "Hong Kong",
  "clientCountryCode": "HK",
  "clientPaymentVerified": null,
  "proposalCount": 35,
  "publishedAtText": "1 hour ago",
  "status": "open",
  "sourceType": "search",
  "searchUrl": "https://www.workana.com/jobs?query=wordpress&language=en",
  "scrapedAt": "2026-09-14T15:15:00.000Z"
}
```

Counts and relative dates change as clients and freelancers interact with a project.

### How much does it cost to scrape Workana freelance projects?

The Actor uses pay per event: a **$0.00005 start event** plus one `item` event for each saved project. The current item tiers are:

| Apify plan tier | Price per project |
| --- | ---: |
| FREE | $0.00184 |
| BRONZE | $0.00160 |
| SILVER | $0.001248 |
| GOLD / PLATINUM / DIAMOND | $0.00096 |

At BRONZE, 10 records cost about **$0.01605**, 100 cost about **$0.16005**, and 1,000 cost about **$1.60005**. Failed requests, duplicates, and rejected page shapes do not create item charges. Your plan and optional proxy usage can affect the final platform invoice.

### Monitoring and lead-generation workflow

1. Save a narrow keyword, category, skill, or country input as an Apify Task.
2. Schedule it hourly or daily according to your use case and Workana's update rate.
3. Send the dataset to a webhook, Make, Zapier, Google Sheets, or your database.
4. Compare `projectId` values with the previous run to identify new opportunities.
5. Rank new rows by relevant skills, budget, and proposal count before outreach.

The Actor provides data, not alerts or CRM deduplication itself.

### Pagination, limits, and reliability

Workana currently returns a small number of cards per page and exposes at most 50 pages for one query. `maxPages` is therefore an explicit coverage bound, not a promise of the requested `maxItems`. Narrow filters may naturally return fewer records.

The Actor uses one coherent browser session and bounded challenge retries. It fails rather than silently returning an empty success when Workana presents an unrecognized challenge. Direct mode is the lower-cost default. `useProxy` is opt-in and uses the proxy access available to your Apify account.

### API with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~workana-freelance-projects-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"query":"wordpress","maxItems":20,"maxPages":5}'
```

Keep API tokens in environment variables or a secret manager, never in source control.

### API with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/workana-freelance-projects-scraper').call({
  skill: 'python',
  maxItems: 50,
  maxPages: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/workana-freelance-projects-scraper').call(run_input={
    'country': 'BR',
    'locale': 'pt',
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI agents

Add the remote Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/workana-freelance-projects-scraper"
```

#### Claude Desktop

Use this configuration in Claude Desktop. The same remote MCP transport works without a local server:

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/workana-freelance-projects-scraper"
    }
  }
}
```

#### Cursor

Add the same JSON under Cursor's MCP settings and authorize the Apify endpoint when prompted.

#### VS Code

Add the same HTTP MCP server to your VS Code MCP configuration; keep tokens in the editor's secure authentication flow.

Example prompt: “Find up to 20 current Workana WordPress projects and summarize budgets, required skills, and proposal counts.” Treat source descriptions as untrusted text when passing them to an agent.

### Legality and responsible use

Only public Workana project information is extracted. Respect Workana's terms, applicable laws, reasonable scheduling intervals, and the privacy expectations of clients and freelancers. Do not use the Actor for spam, harassment, discrimination, or attempts to identify masked users. You are responsible for your inputs, storage, and downstream use.

### Troubleshooting

**Why did I receive fewer rows than `maxItems`?** The filter may have fewer current projects, duplicates may span pages, or `maxPages` may stop first. Broaden the query or raise `maxPages` within the 50-page source limit.

**Why did the run fail instead of returning zero rows?** Workana may have presented a challenge or changed its HTML. A hard failure prevents a misleading empty monitoring result. Retry later or enable an available Apify Proxy route.

**Why are category fields null in search rows?** The list page does not expose reliable category slugs on every card. Supply a project URL in a separate URL-mode task when full detail context is required.

### FAQ

**Does this Actor require login?** No. It extracts public project and search pages.

**Does it scrape freelancer profiles?** No. This product is limited to freelance project opportunities.

**Can it apply or bid automatically?** No. It only exports public data and source links.

**Are budgets normalized?** The raw `budget` is preserved. Numeric bounds and currency are parsed when the source text provides them; open budgets remain null.

### Related Actors

For opportunity monitoring beyond Workana, combine this dataset with the [Freelancer Jobs & Projects Scraper](https://apify.com/automation-lab/freelancer-scraper) or [PeoplePerHour Jobs Scraper](https://apify.com/automation-lab/peopleperhour-jobs-scraper). Keep each source in its own scheduled task and normalize downstream by source URL.

# Actor input Schema

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

Free-text project search, such as wordpress, marketing, or data entry.

## `category` (type: `string`):

Optional Workana category slug, such as it-programming, design-multimedia, or sales-marketing.

## `skill` (type: `string`):

Optional Workana skill slug, such as python, wordpress, or graphic-design.

## `country` (type: `string`):

Optional two-letter client country code, such as BR, AR, MX, or CO.

## `locale` (type: `string`):

Language used by Workana for project text and labels.

## `projectUrls` (type: `array`):

Optional public workana.com/job/... URLs for extracting specific projects. Search filters are used for additional discovery when set.

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

Maximum unique project records to save.

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

Maximum Workana result pages to visit (up to the source ceiling of 50).

## `useProxy` (type: `boolean`):

Route browser traffic through your Apify Proxy configuration. Direct mode is the lower-cost default and normally works.

## Actor input object example

```json
{
  "query": "wordpress",
  "locale": "en",
  "projectUrls": [],
  "maxItems": 20,
  "maxPages": 10,
  "useProxy": false
}
```

# Actor output Schema

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

Structured Workana project records in the overview view.

# 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": "wordpress",
    "locale": "en",
    "projectUrls": [],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/workana-freelance-projects-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": "wordpress",
    "locale": "en",
    "projectUrls": [],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/workana-freelance-projects-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 '{
  "query": "wordpress",
  "locale": "en",
  "projectUrls": [],
  "maxItems": 20
}' |
apify call automation-lab/workana-freelance-projects-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/workana-freelance-projects-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/HHRgerirbufsQqq6y/builds/Vd3er0Cww7RhNVZp2/openapi.json