# Hire a Human for AI Agents (`rainminer/human-tasks`) Actor

Your AI agent hires a real person on Apify — no extra marketplace. Open one task section, send the brief, and the run stays live until they finish. Start with Provide feedback: a human opens your URL and writes what works, what's confusing, and what to change.

- **URL**: https://apify.com/rainminer/human-tasks.md
- **Developed by:** [rainminer](https://apify.com/rainminer) (community)
- **Categories:** AI, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 54.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2,990.00 / 1,000 provide feedbacks

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?

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

## Hire a Human for AI Agents — Live Human-in-the-Loop on Apify

**Your AI can scrape, summarize, and ship. It cannot tell you if a landing page feels cheap.** This Actor lets **AI agents hire a human**, **pay on Apify**, and **wait in realtime** for the result — the same `Actor.call()` contract as every other tool in your stack.

Open one task section, send the brief, get a person. No extra marketplace account. No bounty board. One pay-per-event charge when the human actually finishes.

### What is Hire a Human for AI Agents?

Hire a Human is a **human-in-the-loop API** for agents that already run on [Apify](https://apify.com). Each job is a **foldable input section** with a typed brief — not a blank bounty prompt. Fill **one** section. The run **stays live** until a person submits. The default dataset gets one JSON row you can pipe into the next step.

The live task is **Provide feedback on a URL** (`provideFeedback`): send `{ "provideFeedback": { "url": "https://…" } }`. A human opens the page like a first-time visitor and writes what works, what is confusing, and what to change.

Other sections are templates for jobs agents already ask humans to do (product QA, user testing, desk research, expert calls, site visits, UGC, business verification). They are **not live**. If you fill one, the run **fails immediately** and **you are not charged**.

That is the gap models still miss — trust, fold, CTA, tone — and the reason teams otherwise bolt on a separate “rent a human” vendor.

### Why hire a human from an AI agent?

Use it when the agent needs **judgment on a real page**, not another LLM paraphrase:

- **Launch-day gut check** — “Would a stranger trust this checkout?”
- **Pricing page clarity** — plans, CTAs, and what is buried below the fold
- **Mobile first impression** — hero, tap targets, and the primary button
- **Docs and onboarding** — where a new user gets stuck in the first minute
- **Staging QA** — a person clicks the deploy the agent just shipped
- **Competitor teardown** — honest notes on someone else’s homepage
- **Generated-site review** — the agent built the page; a human has to look at it
- **Form and signup friction** — labels, errors, and “I would bounce here”
- **Trust and proof** — testimonials, logos, and policy pages that feel off
- **Support / help center** — can a person actually find the answer
- **Ads and landing variants** — which of two URLs a person would click
- **Accessibility-as-clarity** — copy a non-expert cannot parse

Agents already call Apify for scrape, PDF, and browser jobs. This is the same rail for **a person**.

### What can this human-in-the-loop Actor do?

- Let **AI agents, MCP clients, and automations** hire a human as a tool
- **Choose the job** from foldable task sections (typed briefs, not a blank prompt)
- **Wait in realtime** — the run does not finish before the human does
- Charge **one pay-per-event** fee per completed Provide feedback
- **Skip that charge** if nobody answers before the timeout
- **Skip that charge** if you fill a task that is not live yet
- Ping Slack, Discord, or any **incoming webhook** with the live work link
- Return **one JSON row**: task, URL, status, feedback, wait time

You also get the rest of the Apify platform: run logs, dataset export (**JSON / CSV / Excel**), schedules, webhooks, and the Apify API.

### How to hire a human through Apify

1. Open [Hire a Human for AI Agents](https://apify.com/rainminer/human-tasks) or start a run from your agent.
2. Open **Provide feedback on a URL (live)** and paste the **URL** the person should open. Add a short “what to look for” if you want.
3. Leave the other task sections empty.
4. Start the run. It stays **RUNNING** until the human submits (or the wait expires).
5. Read `feedback` from the default dataset.

Typical wait is a few minutes. Default timeout is 10 minutes. Timed-out runs are **not** billed as a task event.

#### Input example

```json
{
  "provideFeedback": {
    "url": "https://example.com",
    "instructions": "Focus on the pricing page and the primary CTA."
  },
  "timeoutSecs": 600
}
```

#### Output example

```json
{
  "task": "provide_feedback",
  "url": "https://example.com",
  "status": "completed",
  "feedback": "The hero is clear, but the pricing CTA sits below the fold on mobile.",
  "submittedAt": "2026-08-24T15:04:11.000Z",
  "waitedMs": 187440
}
```

Download the dataset as **JSON**, **CSV**, **HTML**, or **Excel** from the run.

### Task sections

Fill **exactly one** section. Empty and `null` sections are ignored.

| Section                   | Status   | What the brief asks for                  |
| ------------------------- | -------- | ---------------------------------------- |
| Provide feedback on a URL | **Live** | Public URL + optional “what to look for” |
| QA a product              | Not live | Journey to run and evidence to return    |
| User testing              | Not live | Scenario and device                      |
| Desk research             | Not live | Topic, sources, deliverable              |
| Expert call               | Not live | Topic, questions, duration               |
| Site visit                | Not live | Location and what to check               |
| Record a UGC video        | Not live | Product, angle, length                   |
| Verify a business         | Not live | Name, address, what to confirm           |

If you fill a **not live** section, the run errors with: `The "…" task is not available yet. This run was not charged.`

### How much does it cost to hire a human from an AI agent?

You pay two things, both on Apify:

1. **Compute** while the run waits (256 MB by default — small).
2. **One `provide-feedback` event** when a human actually submits. No finish, no task charge.

Exact event prices are on the Actor **Pricing** tab. That is the point versus a standalone marketplace: the agent already has an Apify token, and this job lands on the **same invoice** as your scrapers.

### FAQ

#### Is this realtime?

Yes. The run **blocks until the human finishes** or the timeout hits. Your agent `waitForFinish`es (or polls the run) and then reads the dataset. There is no “file a ticket, check later” queue.

#### How is this different from a rent-a-human marketplace?

General human marketplaces are built for open-ended bounties and, often, work in the physical world. This Actor is built for **agents that already live on Apify**:

|          | Hire a Human (this Actor)                           | Typical human marketplace           |
| -------- | --------------------------------------------------- | ----------------------------------- |
| Pay      | Apify pay-per-event, same bill as your other Actors | Separate account and escrow         |
| Task     | Foldable typed sections (`provideFeedback` live)    | Blank bounty prompt                 |
| Result   | Dataset row when `Actor.call()` returns             | Poll a job id on another API        |
| Best for | Live judgment on a URL                              | Meatspace errands, huge labor pools |

Use a marketplace when you need someone on a street corner. Use this when your agent needs a person to **look at a page and tell the truth**.

#### Who does the work?

A human opens the live work link from the run log (or your notify webhook) and submits. Staff that desk however you want — your reviewer, a contractor, an on-call channel. The agent’s contract does not change: one call, one wait, one JSON row.

#### What if nobody answers?

After `timeoutSecs` the run ends with `status: "timed_out"` and **no task event charge**. Raise the timeout, or make sure a person is watching the webhook.

#### What if I fill a task that is not live?

The run fails immediately. **You are not charged.** Leave those sections empty until they ship.

#### Can I call this from Python or JavaScript?

Yes. Use the [Apify API](https://docs.apify.com/api/v2) or official clients. Same pattern as any other Actor:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('rainminer/human-tasks').call({
  provideFeedback: { url: 'https://example.com' },
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].feedback);
```

#### Will there be more live tasks than Provide feedback?

Yes. Each foldable section is a future job with its own input shape and event price. Provide feedback is live first because URL judgment is what agents ask for constantly.

#### Should I send login-walled pages?

No. Only send **public** URLs. Do not pass credentials, session cookies, or pages behind a user login.

### Integrations

- **Apify API / MCP** — agents hire a human with the same call they use for scrapers
- **Webhooks** — fire the next step when `feedback` lands
- **Slack / Discord** — set **Ping when a human is needed** to an incoming webhook
- **Make, Zapier, n8n** — use the dataset row as the next module’s input

### Support

Want another predefined task section? Open an issue on the Actor page with the input shape (keep it small, priced as its own event).

# Actor input Schema

## `provideFeedback` (type: `object`):

Fill this section to hire a human to review a public URL. You are charged one provide-feedback event only if they submit before the timeout.

## `productQa` (type: `object`):

Not available yet. If you send input here the run errors and you are not charged.

## `userTesting` (type: `object`):

Not available yet. If you send input here the run errors and you are not charged.

## `deskResearch` (type: `object`):

Not available yet. If you send input here the run errors and you are not charged.

## `expertCall` (type: `object`):

Not available yet. If you send input here the run errors and you are not charged.

## `siteVisit` (type: `object`):

Not available yet. If you send input here the run errors and you are not charged.

## `ugcVideo` (type: `object`):

Not available yet. If you send input here the run errors and you are not charged.

## `verifyBusiness` (type: `object`):

Not available yet. If you send input here the run errors and you are not charged.

## `timeoutSecs` (type: `integer`):

Seconds the run waits for a human. You are not charged the task event if they do not finish in time.

## `notifyWebhookUrl` (type: `string`):

Optional Slack, Discord, or generic incoming webhook. We post the live work link when the task is waiting. Leave empty to use the run log (or the Actor-level webhook).

## Actor input object example

```json
{
  "timeoutSecs": 600
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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("rainminer/human-tasks").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("rainminer/human-tasks").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 '{}' |
apify call rainminer/human-tasks --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rainminer/human-tasks"
        }
    }
}

```

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/vI7ugeYysIbBQR2GO/builds/jVQwFAXkZiqRrc440/openapi.json