# $0.9/1k Rentahuman Job Scraper (`architjn/rentahuman-job-scraper`) Actor

Scrape service listings from rentahuman.ai by category or site-wide search. Export human profiles, prices, ratings, and locations — up to 60 jobs per category, no login required.

- **URL**: https://apify.com/architjn/rentahuman-job-scraper.md
- **Developed by:** [Archit Jain](https://apify.com/architjn) (community)
- **Categories:** AI, Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## $0.9/1k Rentahuman Job Scraper

Collect service listings from [rentahuman.ai](https://rentahuman.ai)—the marketplace where people offer tasks and gigs—and export them as structured data. Each row includes the service title, price, human profile link, ratings, verification status, and location. Use it for lead research, competitor scans, or building lists of available gigs by category.

You do **not** need a rentahuman.ai account. The actor reads public browse results only (up to **60 listings per category** per run).

### Input

Configure these fields in the Apify Console **Input** tab before you click **Start**.

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| **Categories** | multi-select | Yes | Video & photo | Pick one or more marketplace categories, or **All categories** for a site-wide list. If you choose All, any other categories you selected are ignored. |
| **Search keyword** | text | No | *(empty)* | Optional filter—same idea as the search box on rentahuman.ai. Matches words in service titles and descriptions. Leave blank to skip. |
| **Sort order** | dropdown | Yes | Top rated | **Top rated**, **Price: high to low**, or **Price: low to high**. |
| **Verified humans only** | checkbox | Yes | Off | When on, only listings from verified humans are returned. |
| **Max items per category** | number | Yes | `60` | How many listings to save **per category** (or per All browse). Maximum is **60** without logging in. |

#### Category options

- All categories  
- Other  
- Personal services  
- Tech & development  
- Design & art  
- Research  
- Writing & content  
- Delivery & errands  
- Companionship  
- Video & photo  
- Hiring  
- Social media  
- Verification  

### Output

Results appear in the run **Dataset** tab—one row per service listing.

| Field | What you get |
|-------|----------------|
| `rank` | Position in the results for that category (1 = first) |
| `category` | Marketplace category (e.g. video & photo) |
| `searchQuery` | Your search keyword, if you used one |
| `sort` | Sort order used for this run |
| `verifiedOnlyFilter` | Whether “verified only” was applied |
| `totalCountInCategory` | Total matching listings on the site for that browse |
| `serviceTitle`, `serviceDescription` | What the human is offering |
| `price`, `priceType`, `hourlyRate` | Listed price and rate info |
| `estimatedMinutes` | Estimated time for the gig, when shown |
| `imageUrls` | Service photos, when available |
| `humanName`, `humanProfileUrl`, `avatarUrl` | Who offers the service and link to their profile |
| `isVerified`, `rating`, `reviewCount` | Trust and review stats |
| `locationCity`, `locationState`, `locationCountry` | Where the human is based |
| `scrapedAt` | When this row was collected |

Download as **JSON**, **CSV**, or **Excel** from the dataset, or pull data via the Apify API and integrations. The **Output** tab also links to a table view and a copy of your run input.

### Pricing Structure

**Pay per result (PPR)** — you are charged for each listing saved to the dataset. Apify platform usage may apply separately depending on your plan. Set a **spending limit** on the run before you start if you are testing or running large jobs.

### Examples

#### Example 1: Video & photo gigs, top rated

**Input:**

```json
{
  "categories": ["video-photo"],
  "sort": "top-rated",
  "verifiedOnly": false,
  "maxItems": 24
}
````

**Output:** Up to 24 rows, all in the Video & photo category, ordered by rating.

#### Example 2: Search “photo” across the whole site

**Input:**

```json
{
  "categories": ["all"],
  "search": "photo",
  "sort": "top-rated",
  "verifiedOnly": false,
  "maxItems": 60
}
```

**Output:** Up to 60 rows from any category that matches “photo”. Each row’s `category` shows which section the listing came from.

#### Example 3: Verified design services, highest price first

**Input:**

```json
{
  "categories": ["design-art"],
  "search": "design",
  "sort": "price-high",
  "verifiedOnly": true,
  "maxItems": 30
}
```

**Output:** Up to 30 verified design listings matching “design”, sorted from highest to lowest price.

**Sample row:**

```json
{
  "rank": 1,
  "category": "design-art",
  "serviceTitle": "Logo design for startups",
  "humanName": "Alex Rivera",
  "price": 150,
  "priceType": "fixed",
  "isVerified": true,
  "rating": 4.8,
  "reviewCount": 12,
  "locationCity": "Austin",
  "locationCountry": "US",
  "humanProfileUrl": "https://rentahuman.ai/humans/..."
}
```

### Best Practices

1. **Start small** — one category and `maxItems: 10` to check the output before a large run.
2. **All categories overrides others** — picking All runs one site-wide search; extra category picks do nothing.
3. **60 is the cap per category** — for more listings, run again with different filters or categories.
4. **Use Search keyword** to narrow All or big categories (e.g. All + `video`).
5. **Many categories add up** — 12 categories × 60 items can mean up to 720 rows and higher cost; use limits in the Console.
6. **Empty results** — if nothing matches (e.g. very strict search + verified only), the run fails with a clear message; loosen filters and try again.

# Actor input Schema

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

One or more categories to scrape. Select "All categories" for a site-wide browse (other selections are ignored when All is selected).

## `search` (type: `string`):

Optional text filter matching service titles and descriptions (same as the site search box). Leave empty to skip.

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

How listings are ordered on rentahuman.ai.

## `verifiedOnly` (type: `boolean`):

When enabled, only listings from verified humans are returned.

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

Maximum services per category (or per All browse). Hard cap is 60 without login.

## Actor input object example

```json
{
  "categories": [
    "video-photo"
  ],
  "search": "",
  "sort": "top-rated",
  "verifiedOnly": false,
  "maxItems": 60
}
```

# Actor output Schema

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

Browse scraped services with human profile, price, category, verification, rating, and profile links.

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

All service records from this run in JSON format.

## `runInput` (type: `string`):

Copy of the Actor input used for this run (categories, search, sort, and filters).

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("architjn/rentahuman-job-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("architjn/rentahuman-job-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call architjn/rentahuman-job-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=architjn/rentahuman-job-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "$0.9/1k Rentahuman Job Scraper",
        "description": "Scrape service listings from rentahuman.ai by category or site-wide search. Export human profiles, prices, ratings, and locations — up to 60 jobs per category, no login required.",
        "version": "0.1",
        "x-build-id": "aYj2fMbu4GYvE4kgt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/architjn~rentahuman-job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-architjn-rentahuman-job-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/architjn~rentahuman-job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-architjn-rentahuman-job-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/architjn~rentahuman-job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-architjn-rentahuman-job-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "categories",
                    "sort",
                    "maxItems",
                    "verifiedOnly"
                ],
                "properties": {
                    "categories": {
                        "title": "Categories",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "One or more categories to scrape. Select \"All categories\" for a site-wide browse (other selections are ignored when All is selected).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "all",
                                "other",
                                "personal-services",
                                "tech-dev",
                                "design-art",
                                "research",
                                "writing-content",
                                "delivery-errands",
                                "companionship",
                                "video-photo",
                                "hiring",
                                "social-media",
                                "verification"
                            ],
                            "enumTitles": [
                                "All categories",
                                "Other",
                                "Personal services",
                                "Tech & development",
                                "Design & art",
                                "Research",
                                "Writing & content",
                                "Delivery & errands",
                                "Companionship",
                                "Video & photo",
                                "Hiring",
                                "Social media",
                                "Verification"
                            ]
                        },
                        "default": [
                            "video-photo"
                        ]
                    },
                    "search": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Optional text filter matching service titles and descriptions (same as the site search box). Leave empty to skip.",
                        "default": ""
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "top-rated",
                            "price-high",
                            "price-low"
                        ],
                        "type": "string",
                        "description": "How listings are ordered on rentahuman.ai.",
                        "default": "top-rated"
                    },
                    "verifiedOnly": {
                        "title": "Verified humans only",
                        "type": "boolean",
                        "description": "When enabled, only listings from verified humans are returned.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items per category",
                        "minimum": 1,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Maximum services per category (or per All browse). Hard cap is 60 without login.",
                        "default": 60
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
