canonical: https://jentic.com/apis/induced.ai/induced

# Induced Autonomous API

Jentic publishes the only available OpenAPI specification for Autonomous API, keeping it validated and agent-ready. Induced.ai's Autonomous API runs browser-based AI agents that complete multi-step tasks on the open web on a user's behalf, such as filling out forms, navigating dashboards, and extracting structured data from authenticated pages. The API exposes six endpoints for kicking off an autonomous task, polling its result, stopping a run, submitting feedback, and a separate /extract pair for one-shot data extraction from a URL. Authentication is via an x-api-key header.

## For AI agents

Run autonomous browser agents that complete web tasks (form fills, dashboard navigation, data extraction) and retrieve structured results. Includes a one-shot URL extraction endpoint.

## Scope

Does not handle hosted browser sessions for human users, screenshot rendering, or proxy management - use for autonomous browser-agent task execution and one-shot URL extraction only.

## Capabilities

- Launch an autonomous browser-based task with a natural-language prompt and target URL via POST /autonomous
- Poll the result of an in-progress or completed autonomous task with GET `/autonomous/{id}`
- Halt a running autonomous task before completion with POST `/autonomous/{id}/stop`
- Submit thumbs-up/down feedback on a completed run to improve the underlying model via POST `/autonomous/{id}/feedback`
- Extract structured data from a single URL in one shot using POST /extract and retrieve it later with GET `/extract/{id}`

## Use cases

### Authenticated Dashboard Data Extraction

Pull metrics out of SaaS dashboards that have no public API by running an autonomous browser agent that logs in, navigates the UI, and returns structured JSON. POST /autonomous accepts a prompt and URL; the agent completes the task and the result is fetched from GET `/autonomous/{id}.` Useful for pulling data from internal admin tools, partner portals, and ad platforms without scraping breakage.

Example prompt: Submit POST /autonomous with a prompt to log into an analytics dashboard and return weekly visitor counts as JSON, then poll GET `/autonomous/{id}` until status is complete.

### Form Submission and Workflow Automation

Automate repetitive web form submissions (vendor onboarding portals, government filings, lead-routing tools) by giving the autonomous agent a goal in natural language. The agent handles cookie banners, multi-step wizards, and conditional fields. Stop endpoints exist if a run goes off-track; feedback endpoints close the learning loop.

Example prompt: Start POST /autonomous with a goal of submitting a vendor onboarding form at a specific URL using supplied company details, and confirm completion.

### One-Shot URL Extraction

Extract structured information from a public URL without orchestrating a full autonomous run. POST /extract takes the URL and a schema/prompt; GET `/extract/{id}` returns the parsed payload. Faster and cheaper than the full /autonomous flow when the data is on a single page and no navigation is required.

Example prompt: Call POST /extract on a product page URL with a schema requesting price, title, and availability, then retrieve the result with GET `/extract/{id}.`

### AI Agent with Browser Tool Access

An LLM-driven agent uses the Autonomous API as its 'browse and act' tool when no first-party API exists for the target service. Through Jentic, the agent searches by intent (e.g., 'run a browser task'), loads the schema, and dispatches the call. The browser agent's structured response feeds back into the parent agent's reasoning loop.

Example prompt: Search Jentic for 'run a browser task', execute POST /autonomous with a natural-language goal, and parse the structured result for the parent agent.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/autonomous` | Execute an autonomous browser-based task |
| GET | `/autonomous/{id}` | Get the result of an autonomous task |
| POST | `/autonomous/{id}/stop` | Stop a running autonomous task |
| POST | `/autonomous/{id}/feedback` | Provide feedback on an autonomous task |
| POST | `/extract` | Extract structured data from a URL |
| GET | `/extract/{id}` | Retrieve a previous extraction result |

## Key resources

- **Autonomous Tasks** — Launch, poll, stop, and provide feedback on multi-step browser-agent runs
- **Extract** — One-shot structured data extraction from a single URL

## Why Jentic

- **Setup:** Wiring the Autonomous API by hand means passing your key in the x-api-key header on every call and tracking each browser task by id yourself. Through Jentic you install once, import the Autonomous API from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** The Autonomous API puts the task id in the URL path (`/autonomous/{id}`), so a rule can pin your agent to reading and giving feedback on tasks it created. You choose the operations it may call, so stopping a running task is not included unless you add it.
- **Credential handling:** Your induced.ai x-api-key value 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.
- **Discovery method:** Agents search Jentic by intent such as 'run a browser task' or 'extract data from a URL', and Jentic returns the matching induced.ai operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Browse AI** — Browse AI offers no-code robots for recurring web scraping and monitoring; induced.ai is closer to a general-purpose autonomous browser agent.
- **Browserless** — Browserless provides headless Chrome as a service for custom Playwright/Puppeteer scripts.
- **Apify API** — Apify runs a marketplace of pre-built scrapers and a custom actor platform.

## FAQ

### Why is there no official OpenAPI spec for Autonomous API?

Induced.ai does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Autonomous API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Autonomous API use?

The Autonomous API uses an API key passed in the 'x-api-key' header on every request. Through Jentic, the key is stored encrypted in your Jentic One instance and is injected at execution time, so the agent never sees the raw key.

### Can I extract data from pages that require a login?

Yes. The /autonomous endpoint accepts natural-language goals that include credentials or session steps so the agent can authenticate and navigate the target site, then return structured data. For purely public pages, the lighter /extract endpoint is faster.

### What are the rate limits for the Autonomous API?

Rate limits are not encoded in the spec. They are enforced per API key and depend on plan tier; check the induced.ai dashboard or contact induced.ai support for current concurrency and per-minute limits.

### How do I run a browser task through Jentic?

Search Jentic with the query 'run a browser task' to find POST /autonomous, load its input schema (prompt, URL), and execute. Poll GET `/autonomous/{id}` for the result. Get started with Jentic One, the self-hosted execution layer.

### How do I stop a long-running autonomous task?

Call POST `/autonomous/{id}/stop` with the task ID returned from the original POST /autonomous call. The agent will halt at the next safe step and the GET `/autonomous/{id}` endpoint will report the stopped state with whatever partial result was produced.

### Can I limit what my agent is allowed to do with the Autonomous API?

Yes. Because you run Jentic One yourself, your own rules decide which of the six Autonomous API operations your agent may call and which credentials it may use. Since the task id lives in the URL path at `/autonomous/{id}`, you can pin the agent to reading and giving feedback on tasks it created while leaving POST `/autonomous/{id}/stop` off the allowed list unless you explicitly add it. The agent only ever gets the operations you grant, so it cannot halt a running task or reach any endpoint you have not scoped in.