Install Jentic One Beta
Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the Microworker API, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.
Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.
Step 1: Jentic One Host machine
# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fmicroworker.app%2Fmicroworker" | shStep 2: Agent machine
# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fmicroworker.app%2Fmicroworker" | sh
jentic register # connects your agent to your Jentic One instanceJentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.
What an agent can do with Microworker API.
Create a task draft with title, instructions, `reward_minor`, and `slots_total`, then fund it to publish from your balance
Get a recommended reward per worker from the pricing guide before posting a task
Reject a submission with a `rejection_reason`, ask the worker for a fix, or refuse at once with final set to true
Pause, resume, cancel, or wind down every task in an order by its order reference
GET STARTED
Decide disputes on your tasks by paying the worker, upholding your refusal, or sending the work back for one more try
Confirm a postback conversion with the worker's `mw_click` code so the worker is paid at once
Subscribe a webhook endpoint to events such as `submission.created` and `task.completed`, and send it a test ping
Patterns agents use Microworker API for, with concrete tasks.
★ AI agent crowd task operator
An agent running small human-verification jobs needs to post tasks, watch for submissions, and act on bad ones. Through Jentic it searches for 'post a paid micro-task', loads the Microworker task create operation, and sends a title, instructions, reward_minor, and slots_total while the mwk_ API key is injected at call time. Because a task is a draft until funded, the agent can create it, check the fee preview, and fund it as a separate, deliberate step.
POST /tasks with title 'Test our sign-up form', instructions, reward_minor 25, and slots_total 50, read fee_minor from the response, then POST /tasks/{id}/fund to publish it
Submission quality review
Paid proof work needs a quick quality pass. The submissions feed lists proofs across all tasks filtered by status, task_id, order_ref, or updated_since, proof screenshots can be downloaded, and a first refusal sends the proof back to its worker as a fix request with your reason. Only a refusal of the fixed proof, or one sent with final true, is final.
Call GET /submissions with task_id 812 and status 'pending', download each proof with GET /proofs/{file}, and POST /submissions/{id}/reject with rejection_reason 'Screenshot does not show the confirmation page' for any that fail
Sign-up conversion payouts
Tasks posted with verify_method postback give each worker a personal link carrying an mw_click code. When your own system sees a real sign-up, it confirms the conversion with that code and the worker is paid at once; a repeated code answers already true, so retries are safe. Paid conversion work can later be sent back for a fix or have its pay reversed.
POST /conversions with click 'mwc_8f2k1' and reference 'signup-20441' after the user's account is verified, and check the returned status
Campaign order control
Larger campaigns are split into several tasks under one order reference. The order endpoint returns the order's tasks and their totals, and one call pauses, resumes, cancels, or winds down every task in it, so an agent can halt a campaign the moment a landing page breaks.
Call GET /orders/{ref} for order 'spring-launch', then POST /orders/{ref}/pause and confirm each task now reports paused
44 endpoints — the microworker api posts paid micro-tasks for crowd workers, funds them from your balance, and tracks the submissions workers send back, all from your own server.
METHOD
PATH
DESCRIPTION
/tasks
Create a task draft, or create and fund it
/tasks/{id}/fund
Fund a draft and publish it
/submissions
Submissions on all your tasks in one feed
/submissions/{id}/reject
Reject a submission
/conversions
Confirm a conversion and pay the worker
/pricing/guide
Recommend a reward per worker
/wallet
Balance and newest ledger entries
/webhooks
Add a webhook endpoint
/tasks
Create a task draft, or create and fund it
/tasks/{id}/fund
Fund a draft and publish it
/submissions
Submissions on all your tasks in one feed
/submissions/{id}/reject
Reject a submission
/conversions
Confirm a conversion and pay the worker
/pricing/guide
Recommend a reward per worker
/wallet
Balance and newest ledger entries
/webhooks
Add a webhook endpoint
What agents get from Jentic-routed access to this vendor.
Setup
Wiring Microworker by hand means choosing between bearer and X-API-Key, picking a key with the right scopes, converting money to integer cents, and handling its per-key funding and write limits. Through Jentic you install once, import Microworker from the API Directory, store the key once, and your agent calls it.
Permission scoping
Microworker puts the task id in the URL path (/tasks/{id}/...), so a rule can pin your agent to one task and the operations you pick. You choose the operations it may call, so money-moving ones like funding a task, resizing it, or confirming conversions are not included unless you add them.
Credential isolation
Your Microworker API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
Intent-based discovery
Agents search Jentic by intent such as 'post a paid micro-task' or 'reject a worker submission', and Jentic returns the matching Microworker operation with its input schema, including the required task fields.
Alternatives and complements available in the Jentic catalogue.
Specific to using Microworker API through Jentic.
What authentication does the Microworker API use?
Per its OpenAPI spec, the Microworker API takes an API key from microworker.app/developers, sent either as a bearer token (`Authorization: Bearer mwk_...`) or in the `X-API-Key` header. Keys carry scopes: read, tasks, fund, review, and conversions. Through Jentic the key is stored by your own instance and injected at call time, so it never sits in the agent's context.
What are the rate limits for the Microworker API?
The OpenAPI spec states 120 requests a minute per key, of which 30 can be funding, live resize, rejection, and conversion calls, plus 3000 writes an hour per key and 10000 an hour from one network address. GET /me returns the limits for the calling key.
Can I approve Microworker submissions myself?
Only on your own tasks created with employer_review set to true, through POST /submissions/{id}/approve. On other tasks every proof is decided by automatic review and the approve call answers 403 automatic_approval_only; a held proof there is cleared with POST /submissions/{id}/release instead.
How much does it cost to post a task on Microworker?
Per the spec, money is in integer cents and the platform fee is 5% plus $1.00 per task, with no fee for verified employers. Rewards start at $0.02 per worker, or $0.05 when the task asks for a screenshot or a file, and the fee preview is returned as fee_minor when you create a draft.
Is there a Microworker MCP server?
You don't need an MCP server to give your agent Microworker. Jentic connects it directly from the API Directory: import it, store your API key once, and your agent discovers the task, submission, and order operations on demand instead of loading them all into its context.
How do I post a task on Microworker through Jentic?
Search Jentic for 'post a paid micro-task', load the task create operation, and execute POST /tasks with title, instructions, reward_minor, and slots_total, then fund it with POST /tasks/{id}/fund. To run it on your own infrastructure, install Jentic One from its GitHub repo.
Can I limit what my agent is allowed to do with Microworker?
Yes. Write a rule that allows GET /tasks/812/submissions, GET /proofs/{file}, and POST /submissions/{id}/reject only, and the agent can review and refuse proofs on that task while posting, funding, and dispute decisions stay with you. Every call it makes is logged.
For Agents
Create, fund, and run Microworker crowd tasks, then review submissions, settle disputes, and confirm conversions, with integer-cent pricing and signed webhook events.
Use for: I need to post a task asking 50 workers to test my sign-up form, Check whether my wallet balance covers another task, List all pending submissions on task 812, Reject this submission and tell the worker the screenshot is missing
Not supported: Does not hire freelancers for long contracts, run payroll, or process customer payments. Use for posting, funding, and reviewing paid crowd micro-tasks on Microworker only.
The Microworker API posts paid micro-tasks for crowd workers, funds them from your balance, and tracks the submissions workers send back, all from your own server. A task is created as a draft with a title, instructions, a reward per worker in integer cents, and a number of places, then funded to publish it; live tasks can be paused, resumed, edited, resized, bumped, wound down, or given notes for the workers on them. Submissions are reviewed automatically unless the task asks for employer review, and the API lets you reject a proof, ask for a fix, release a held proof, or approve one on an employer-review task. It also covers disputes, orders that group several tasks, funding invoices, signed webhooks, and conversion postbacks that pay a worker when a real sign-up is confirmed.
This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.
Base layer of spec validity and structural soundness.
Aggregated quality score from linter diagnostics, weighted by severity.
Percentage of `$ref` references that resolve successfully.
Checks whether the API description parses successfully and conforms to its declared specification (e.g., OpenAPI).
Structural correctness score based on schema issues using logarithmic dampening.
Clarity, completeness, and ingestion readiness for developers and tooling.
How richly the API is illustrated with examples.
Percentage of examples that conform to their schemas.
Percentage of operations with complete response definitions (success, client error, server error).
Health of API ingestion, bundling, and resolution within Jentic pipelines.
Semantic breadth, depth, and agent comprehension for AI systems.
Coverage of descriptions across API elements.
Coverage of RFC 9457 Problem Details for error responses.
Coverage, uniqueness, and casing consistency of operationIds for AI inference.
Coverage of summaries across operations/tags/info.
Functional utility, complexity comfort, and AI orchestration readiness.
Agent comfort level based on API operational and structural complexity.
Trust, risk posture, and security compliance.
Average quality of security schemes based on authentication method strength (weakest link for OAuth2).
Findability, semantic richness, and reasoning readiness.
Clarity and depth of descriptions across API elements.
Score it yourself
Every API in the directory is allowlisted, so you can re-score it with no key required.
npx @jentic/api-scorecard-cli score <openapi-url>