# Workana Jobs Scraper - LATAM Freelance Projects, $0.002/Job (`gio21/workana-scraper`) Actor

Scrape freelance projects from Workana (LATAM). Title, budget (parsed), skills, client, country, bids. Keyword, category, country and language filters. No login. $0.002/job.

- **URL**: https://apify.com/gio21/workana-scraper.md
- **Developed by:** [Gio](https://apify.com/gio21) (community)
- **Categories:** Jobs, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 139 total users, 41 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.00 / 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.

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

## Workana Jobs Scraper - LATAM Freelance Projects, $0.002/Job

Scrape freelance project listings from [Workana](https://www.workana.com), the largest freelancer marketplace in Latin America. Extract title, budget, skills, client info and bid count for any keyword, category or country, in Portuguese, Spanish or English.

### Why use this scraper

Workana does not offer a public API, and its listings shift fast: hot projects can already have dozens of bids within a day. Freelancers, agencies and market researchers who want to track demand across LATAM's biggest gig marketplace are left refreshing search pages by hand or paying for tools that only cover a single country or language.

This actor reads Workana's own search results directly, across all three interface languages Workana supports, with country and category filters applied before you pay for a single result. Budgets come back already parsed into minimum, maximum and currency instead of a raw text string you have to interpret yourself.

### Overview

Given a keyword, category and/or country, the actor returns one row per project listing it finds on Workana, up to the cap you set. A typical batch of 50 listings completes in a few seconds, since it reads Workana's search pages directly with no browser rendering step. Every record includes the project title, full description, structured budget, required skills, client name, country, bid count and whether the project is marked urgent.

### Supported inputs

- **Keyword search** - `keyword` filters by any term Workana's own search accepts, for example `"marketing"` or `"desenvolvimento"`.
- **Category filter** - `category` accepts a Workana category slug (`web-development`, `design`, `writing`, `marketing`, `it-programming`, `e-commerce`, `admin-support`, `seo` and others) to target a specific niche.
- **Country filter** - `country` accepts a 2-letter code (`BR`, `AR`, `MX`, `CO` and others); leave empty to cover all LATAM countries Workana lists.
- **Interface language** - `language` switches the site language Workana serves results in: Portuguese (`pt`), Spanish (`es`) or English (`en`).
- **Result cap** - `maxItems` caps how many projects are returned and billed in a single run.

All filters can be combined, for example web-development projects in Brazil searched through the Portuguese interface.

### Use cases

- **Freelancers** monitoring new postings that match their skill set, to bid before a listing accumulates dozens of proposals.
- **Agencies and lead-generation teams** identifying which clients are actively posting work in a given niche, with budget already parsed for quick qualification.
- **Market researchers** tracking demand, average budgets and in-demand skills across the LATAM gig economy, broken down by country or category.
- **Competitive intelligence teams** watching what categories and budgets competitors in an agency's space are bidding on.

### How it works

The actor requests Workana's own search results for the keyword, category, country and language combination given, and reads the listing and project-detail data Workana serves on those pages directly. Because it reads structured page data rather than rendering the page in a browser, a batch of listings comes back in seconds rather than minutes. Budget strings (for example "USD 100 - 250" or "Menos de USD 15 / hora") are parsed into `budgetMin`, `budgetMax`, `budgetCurrency` and an `isHourly` flag so you do not have to parse free text downstream.

### Input configuration

Default search, Brazil, Portuguese interface:

```json
{
  "keyword": "marketing",
  "country": "BR",
  "language": "pt",
  "maxItems": 50
}
```

Web development category across all countries, English interface:

```json
{
  "category": "web-development",
  "language": "en",
  "maxItems": 100
}
```

Keyword search in Mexico, Spanish interface, small batch:

```json
{
  "keyword": "diseno grafico",
  "country": "MX",
  "language": "es",
  "maxItems": 20
}
```

### Output sample

Real output from a production run against Workana (description trimmed for readability; the actor does not truncate it):

```json
[
  {
    "slug": "editores-de-video-para-criacao-de-conteudo-dinamico-e-criativos-em-alto-volume",
    "title": "Editores de Video para Criacao de Conteudo Dinamico e Criativos em Alto Volume",
    "url": "https://www.workana.com/job/editores-de-video-para-criacao-de-conteudo-dinamico-e-criativos-em-alto-volume",
    "description": "Estamos em busca de editores de video talentosos e experientes para nos ajudar na criacao de conteudo dinamico e envolvente...",
    "budget": "USD 100 - 250",
    "budgetMin": 100,
    "budgetMax": 250,
    "budgetCurrency": "USD",
    "isHourly": false,
    "deadline": null,
    "skills": ["Edicao de video", "Adobe Premiere", "Adobe After Effects", "Motion Graphics"],
    "authorName": "P.",
    "country": "Brasil",
    "countryCode": "BR",
    "totalBids": 32,
    "isUrgent": false,
    "postedDate": "Ontem",
    "publishedDate": "Publicado: Ontem",
    "scrapedAt": "2026-09-21T19:13:02.673Z"
  }
]
```

### Key output fields

| Field | Type | Description |
|-------|------|--------------|
| `slug` | string | Workana's URL slug for the project, useful for deduplication |
| `title` | string | Project title |
| `url` | string | Direct link to the project on Workana |
| `description` | string | Full project description |
| `budget` | string | Budget exactly as Workana displays it |
| `budgetMin` / `budgetMax` | number or null | Budget range parsed from `budget` |
| `budgetCurrency` | string | Currency of the budget, usually USD |
| `isHourly` | boolean | True when the budget is an hourly rate rather than fixed price |
| `skills` | array of string | Skills required, as listed on the project |
| `authorName` | string | Client's display name on Workana |
| `country` / `countryCode` | string | Client's country, full name and 2-letter code |
| `totalBids` | integer | Number of proposals already submitted |
| `isUrgent` | boolean | True when Workana flags the project as urgent |
| `postedDate` | string | Relative posting date as shown by Workana |
| `scrapedAt` | string (ISO date) | When this actor fetched the record |

### Pricing

Pay-per-result pricing, no subscription:

| Event | Price |
|-------|-------|
| Job scraped | $0.002 per job |
| Actor start | $0.00005 per GB of memory (one-time per run) |

1,000 listings costs $2 plus a negligible per-run start fee.

### What makes this richer than the competition

Compared to two other Workana scrapers on the Store:

- **delectable_incubator/workana-jobs-scraper-low-cost** covers the same site but does not document structured budget parsing (`budgetMin`/`budgetMax`/`budgetCurrency`/`isHourly`), leaving budget as a raw string to parse downstream.
- **getdataforme/workana-job-scraper** covers Workana listings but does not expose a language input, so results only come back in a single interface language rather than the buyer's choice of Portuguese, Spanish or English.

This actor parses budgets into structured fields at extraction time and lets you choose the interface language per run, so multi-country LATAM operations do not need three separate scrapers for three languages.

### Notes & limitations

- Coverage matches what Workana's own search returns for the keyword/category/country combination given; very broad searches may need to be split into narrower queries to see deeper pages.
- `budgetMin`/`budgetMax` come back `null` when Workana's own listing does not state a numeric budget.
- `deadline` is only populated when the client sets one on Workana; most listings leave it blank.
- `description` is returned in whichever language the client originally wrote the project in, regardless of the `language` interface setting, since that setting controls the site chrome Workana serves, not a translation of client-submitted text.
- This actor does not submit bids, message clients, or interact with Workana beyond reading public listings.

Because listings move fast on Workana, most buyers get the most value by scheduling this actor rather than running it once. A daily or hourly [schedule](https://docs.apify.com/platform/schedules) with a fixed `keyword`/`category`/`country` combination, paired with deduplication on `slug` in your own storage, turns this into a live alert feed: only genuinely new projects reach your pipeline, and you never pay twice for the same listing. Pair the run with a webhook on run completion to push new rows straight into Slack, a spreadsheet or a CRM without polling the dataset manually.

### FAQ

**Do I need a Workana account to use this?**
No. The actor reads public project listings; no login or cookies are required.

**Can I search in more than one language in the same run?**
No, `language` sets one interface language per run. Run it again with a different `language` value to cover another one.

**Why is `budgetMin` or `budgetMax` empty on some rows?**
Workana's own listing did not state a numeric budget for that project; the actor returns exactly what Workana shows.

**Can I filter by category and country at the same time?**
Yes, `category` and `country` can be combined with `keyword` in the same run.

**Can I deduplicate results across scheduled runs?**
Yes, store `slug` and skip rows you have already seen on later runs.

**How many results can one run return?**
Workana paginates search results; `maxItems` caps what a single run extracts and bills. For deeper coverage, run again with a narrower keyword or category.

### For AI Agents & LLM Apps

This actor is available over the [Apify MCP server](https://mcp.apify.com) for direct use inside Claude, ChatGPT and other MCP-compatible agents, or via the Apify API for a synchronous call that returns dataset items in one request:

```bash
curl "https://api.apify.com/v2/acts/gio21~workana-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keyword": "marketing", "country": "BR", "language": "pt", "maxItems": 20}'
```

The response is a JSON array of project objects, ready to feed into an agent's context or a lead-qualification pipeline without any extra parsing step.

### Disclaimer

Workana is a trademark of its respective owner. This actor is an independent tool that reads publicly available Workana project listings; it is not affiliated with, endorsed by, or sponsored by Workana.

### SEO Keywords

Workana scraper, Workana API, Workana jobs scraper, freelance jobs LATAM, Workana project listings, Workana Brazil scraper, Workana data extraction, freelance marketplace scraper, Workana lead generation, Workana job search API.

# Actor input Schema

## `keyword` (type: `string`):

Palavra-chave para buscar projetos (ex: 'marketing', 'desenvolvimento', 'design'). Deixe vazio para todos os projetos.

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

Slug da categoria da Workana. Ex: 'web-development', 'design', 'writing', 'marketing', 'it-programming', 'e-commerce', 'admin-support', 'seo'.

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

Código do país em 2 letras (ex: 'BR' para Brasil, 'AR' para Argentina, 'MX' para México, 'CO' para Colômbia). Deixe vazio para todos os países.

## `language` (type: `string`):

Idioma dos resultados da Workana: 'pt' (português), 'es' (espanhol), 'en' (inglês).

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

Número máximo de projetos a extrair

## Actor input object example

```json
{
  "country": "BR",
  "language": "pt",
  "maxItems": 20
}
```

# Actor output Schema

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

Freelance job listings from Workana — includes title, budget, country, skills, proposals, and more.

# 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 = {
    "country": "BR",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("gio21/workana-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 = {
    "country": "BR",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("gio21/workana-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 '{
  "country": "BR",
  "maxItems": 20
}' |
apify call gio21/workana-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gio21/workana-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/AHSytPimxdPxhsj8r/builds/cgY3WCs1LVfrJEf7N/openapi.json