# Codeable Scraper (`crawlerbros/codeable-scraper`) Actor

Scrape Codeable's curated WordPress developer marketplace - browse the developer directory by specialty or country, or fetch full profile detail (rating, completed projects, skills, reviews) for specific developers.

- **URL**: https://apify.com/crawlerbros/codeable-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Codeable Scraper

Scrape [Codeable](https://www.codeable.io) — the curated marketplace of vetted, senior WordPress developers. Browse the public developer directory by specialty or country, or pull full profile detail (rating, completed projects, skills, client reviews) for specific developers. HTTP-only, no login, no cookies, no proxy required.

### What this actor does

- **Two modes:** `browseDevelopers` (directory listing) and `developerProfile` (full profile detail)
- **234 specialty filters** — WooCommerce, Elementor, PHP, Custom API Integration, Security, and more
- **64 country filters** — narrow the directory to developers based in a specific country
- **Quality filters** — minimum rating, minimum completed projects, spoken language
- **Full profile detail** — bio, typical projects, skills, hire link, up to 10 recent client reviews, and portfolio/case-study items per developer
- **Empty fields are omitted** — every record only contains data actually present on the page

### Output fields

#### Directory listing (`mode=browseDevelopers`)

| Field | Description |
|---|---|
| `developerSlug` | Codeable's URL slug for the developer |
| `name` | Developer / agency display name |
| `profileUrl`, `sourceUrl` | Link to the full profile page |
| `avatarUrl` | Profile photo URL |
| `rating` | Overall rating out of 5 |
| `completedProjects` | Number of completed Codeable projects |
| `clientsCount` | Number of distinct clients served |
| `locationCity`, `locationCountry` | Where the developer is based |
| `countrySlug`, `countryUrl` | Codeable's country landing page for this developer |
| `languages` | Spoken languages |
| `memberSince` | Date the developer joined Codeable |
| `yearsOnPlatform` | Years since joining |
| `bio` | Short bio / tagline |
| `specialties`, `specialtySlugs` | Listed specialties (tags) |
| `recordType` | Always `developer` |
| `scrapedAt` | UTC timestamp of the scrape |

#### Profile detail (`mode=developerProfile`)

All directory-listing fields above, plus:

| Field | Description |
|---|---|
| `title` | Professional title (e.g. "Full-Stack Developer") |
| `ratingCount` | Total number of ratings behind the overall `rating` — a more complete count than `reviewsShown`, which only reflects reviews rendered on the initial page load |
| `about` | Full-length about/bio text |
| `typicalProjects` | Types of projects the developer usually takes on |
| `skills`, `skillSlugs` | Full skill list from the profile's Skills panel |
| `hireUrl` | Direct link to start a project with this developer |
| `developerId` | Codeable's internal numeric developer ID |
| `reviews` | Up to 10 recent client reviews, each with `authorName`, `rating`, `reviewBody`, `datePublished` |
| `reviewsShown` | Number of reviews included in this record |
| `portfolioProjects` | Portfolio/case-study items shown on the profile — each with `title`, `url` (the live external site the developer built), `description`, `imageUrl` |
| `portfolioProjectsShown` | Number of portfolio items included in this record |
| `profileLastUpdated` | UTC timestamp of when the developer last edited their public profile |
| `recordType` | Always `developerProfile` |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `browseDevelopers` | `browseDevelopers` or `developerProfile` |
| `searchQuery` | string | – | Free-text keyword search against Codeable's own directory search box (mode=browseDevelopers); combines with `specialty`/`country` |
| `specialty` | select | – | Filter directory by specialty (mode=browseDevelopers); leave blank to browse all developers |
| `country` | select | – | Filter directory by country; if `specialty` is also set, results are fetched by country and then filtered client-side to that specialty |
| `developerIdentifiers` | array | `["nishit-kumar"]` | Developer slugs or profile URLs (mode=developerProfile) |
| `minRating` | number | – | Drop developers rated below this (1-5) |
| `minCompletedProjects` | integer | – | Drop developers with fewer completed projects |
| `language` | select | – | Only keep developers who speak this language |
| `maxItems` | integer | `20` | Hard cap on emitted records (1-500) |

#### Example: browse WooCommerce developers in India, rated 4.5+

```json
{
  "mode": "browseDevelopers",
  "specialty": "woocommerce",
  "country": "india",
  "minRating": 4.5,
  "maxItems": 50
}
```

#### Example: full profile for specific developers

```json
{
  "mode": "developerProfile",
  "developerIdentifiers": ["nishit-kumar", "felix-kipyego"]
}
```

#### Example: browse the full directory, no filters

```json
{
  "mode": "browseDevelopers",
  "maxItems": 100
}
```

### Use cases

- **Agency sourcing** — shortlist vetted WordPress developers by specialty, country, or rating before reaching out
- **Competitive research** — track skill and specialty distribution across a curated freelance marketplace
- **Recruiting pipelines** — build a candidate list filtered by language and completed-project volume
- **Market research** — analyze reviews and ratings across a niche developer marketplace
- **Lead enrichment** — pull full bios, skills, and reviews for specific developer profiles you already have slugs/URLs for

### Data source

This actor covers Codeable's two public, unauthenticated surfaces: the **developer directory/browse** pages (filterable by specialty or country) and **individual developer profile pages**. Codeable's client-facing project/task submission flow (posting a job and receiving proposals) requires a logged-in client account and is not publicly browsable — no public job/task board exists on codeable.io, so it is out of scope for this actor.

### FAQ

**Do I need a Codeable account or API key?** No. Everything this actor scrapes is publicly visible on codeable.io without logging in.

**What's the difference between `specialties` and `skills`?** `specialties` (directory listing) is a short list of tags shown on the developer card. `skills` (profile detail) is the fuller list shown in the profile's dedicated Skills panel — usually a superset. Note that Codeable's own directory card only ever renders a truncated subset of a developer's tags, so when filtering `browseDevelopers` by `specialty`, an individual record's `specialties`/`specialtySlugs` field is not guaranteed to literally contain the filtered specialty — the developer genuinely matches it on Codeable's server-side filter, it just may not be among the handful of tags the card happens to display. Use `mode=developerProfile` for the full, authoritative specialty/skill list.

**Can a `country`-filtered record ever show a different `locationCountry`?** No — Codeable's own `/wordpress-developers/country/<x>/` listing pages occasionally include a developer whose displayed profile address is in a different country (an upstream data-tagging inconsistency on Codeable's side, confirmed live — the `germany` listing included a Miami-based developer alongside genuinely Germany-based ones). This actor re-checks the requested country against each card's own displayed `locationCountry` and drops any mismatch client-side, so a `country`-filtered run never emits a record from the wrong country. A card with no parsed location is passed through rather than dropped (can't tell, don't over-filter).

**Why are reviews capped at 10?** Codeable's profile pages render up to 10 recent reviews without pagination; that's the full set publicly visible per developer.

**How many portfolio items are included?** All portfolio items rendered on the initial profile page load — typically up to ~20. Codeable lazy-loads further items behind a "Load more" button that requires JavaScript, so items beyond the initial load aren't included.

**Can I combine `specialty` and `country`?** Yes. They live under different URL namespaces on Codeable, so only one can drive the server-side listing request — when both are set, the actor fetches by `country` and then applies `specialty` as a client-side filter against each developer's own `specialtySlugs`, so results are genuinely both from that country and listing that specialty. Combine with `minRating`/`minCompletedProjects`/`language` for further narrowing.

**How fresh is the data?** Live — every run scrapes the current codeable.io pages directly; there's no caching layer.

**Why did a full-directory `browseDevelopers` run (no filters, high `maxItems`) return fewer records than the directory's total developer count?** Codeable's directory listing can reorder slightly while a multi-page crawl is still in progress, occasionally shifting a developer onto a different page number between two of this run's own requests. The actor dedupes by developer slug across the whole run so a shift like that never produces two records for the same developer — but on a large unfiltered crawl it can mean a run legitimately lands a bit under the full directory total in one pass. If that happens, `statusMessage` on the run reports how many duplicate listings were skipped; simply re-running picks up any developers that one run's timing happened to miss.

**Is `rating` out of 5?** Yes, matching Codeable's own 5-star rating display.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `searchQuery` (type: `string`):

Free-text keyword search against Codeable's own developer-directory search box (e.g. a name, agency, or skill keyword). Combines with `specialty` and/or `country`.

## `specialty` (type: `string`):

Filter the directory to developers listing this specialty/skill. Leave blank to browse all developers. If `country` is also set, the browse listing is fetched by country (Codeable can't combine both in one URL) and `specialty` is then applied as an additional client-side filter against each developer's listed specialties.

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

Filter the directory to developers based in this country. Leave blank to ignore. When both `country` and `specialty` are set, the browse listing is fetched by country and `specialty` is applied on top as a client-side filter.

## `developerIdentifiers` (type: `array`):

Codeable developer slugs (e.g. `nishit-kumar`) or full profile URLs.

## `minRating` (type: `number`):

Drop developers with an overall rating below this (1-5).

## `minCompletedProjects` (type: `integer`):

Drop developers with fewer completed projects than this.

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

Only keep developers who list this language among the languages they speak.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "browseDevelopers",
  "searchQuery": "",
  "specialty": "",
  "country": "",
  "developerIdentifiers": [
    "nishit-kumar"
  ],
  "language": "",
  "maxItems": 20
}
```

# Actor output Schema

## `developers` (type: `string`):

Dataset containing all scraped Codeable developer records.

# 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 = {
    "mode": "browseDevelopers",
    "searchQuery": "",
    "specialty": "",
    "country": "",
    "developerIdentifiers": [
        "nishit-kumar"
    ],
    "language": "",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/codeable-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 = {
    "mode": "browseDevelopers",
    "searchQuery": "",
    "specialty": "",
    "country": "",
    "developerIdentifiers": ["nishit-kumar"],
    "language": "",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/codeable-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 '{
  "mode": "browseDevelopers",
  "searchQuery": "",
  "specialty": "",
  "country": "",
  "developerIdentifiers": [
    "nishit-kumar"
  ],
  "language": "",
  "maxItems": 20
}' |
apify call crawlerbros/codeable-scraper --silent --output-dataset

```

## MCP server setup

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