VIFE FOR DEVELOPERS

The AI agent API that delivers finished work

Send a task. Vife plans it, researches, browses and builds — then hands back slides, documents, images and video as files. One key works over REST, MCP and the command line.

  • One key
  • REST
  • MCP
  • CLI
POST /v1/tasks · mode slide
$ curl -X POST https://api.vife.ai/v1/tasks \
  -H "Authorization: Bearer $VIFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "slide",
    "input": "A 4-slide launch deck for AURA, our desk lamp"
  }'
  1. 202status queued
  2. runningPlan
  3. Searching the web
  4. Planning presentation
  5. Authoring presentation
  6. Checking presentation
  7. Exporting presentation
  8. completed1 file · aura-launch.pptx
  9. webhooktask.completed → 200 OK
  10. $
Cover slide of AURA, a launch deck for a modular desk lampcompleted
aura-launch.pptx4 slides
  • 8task modes
  • 7webhook events
  • 1key for REST, MCP and CLI
  • 1 GiBper uploaded file

Why a task API

Model APIs return text. Vife returns the work.

A model API

promptmodeltokens

You get text back. Everything around it is yours to build:

  • Search, browsing and reading sources
  • Tool calls, retries and state for long jobs
  • Turning text into a deck, a document or a video file

The Vife API

taskVife agentfiles

You get the finished work back. The agent does the rest:

  • Plans the job, searches and browses on its own
  • Uses tools, skills and your connected apps
  • Renders slides, documents, sheets, images, video and audio as files
  • Runs as long as it needs; a webhook tells you when it is done

01Quickstart

From key to finished file in three calls

No SDK to install. The API is plain JSON over HTTPS, so cURL, fetch in Node 22 and Python requests all work as written.

  1. 1

    Create a key

    In Vife › Settings › Developer. A key is full or read-only.

    vife_sk_…
  2. 2

    Create a task

    POST the input and a mode. The call answers 202 at once.

    POST /v1/tasks
  3. 3

    Get the result

    A signed webhook when it finishes, or poll the task.

    task.completed
# Create a task
curl https://api.vife.ai/v1/tasks \
  -H "Authorization: Bearer $VIFE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: launch-deck-001" \
  -d '{"mode": "slide", "input": "Turn this product brief into a 10-slide launch deck: …"}'

# Read it again until status is completed
curl https://api.vife.ai/v1/tasks/$TASK_ID \
  -H "Authorization: Bearer $VIFE_API_KEY"
202 Accepted · Task, abridged
{
  "object": "task",
  "id": "4f9d2c1e-8b7a-4c3d-9e2f-1a0b9c8d7e6f",
  "mode": "slide",
  "status": "queued",
  "source": "api",
  "result": null,
  "pending_input": null,
  "credits_used": 0,
  "web_url": "https://vife.ai/agent/4f9d2c1e-8b7a-4c3d-9e2f-1a0b9c8d7e6f"
}
Your endpoint receives · abridged
{
  "id": "0b6e1f7a-3c2d-4e5f-9a8b-7c6d5e4f3a2b",
  "type": "task.completed",
  "created_at": "2026-11-13T09:04:12.000Z",
  "api_version": "2026-11-11",
  "data": {
    "task": {
      "id": "4f9d2c1e-8b7a-4c3d-9e2f-1a0b9c8d7e6f",
      "status": "completed",
      "result": {
        "artifacts": [
          {
            "object": "file",
            "name": "launch-deck.pptx",
            "url": "https://file.vife.ai/…/launch-deck.pptx"
          }
        ]
      }
    }
  }
}
Full quickstart

02Platform

What you can build with it

Everything the app can do with a task is an API call: start it, feed it files, follow it, schedule it and switch what it may use.

  • Start an agent run in any of 8 modes and follow it to the end.

  • Signed events when work finishes, fails or needs you.

  • Upload inputs up to 1 GiB, download every file a task made.

  • Generate images, video and audio through the same task call.

  • Put a task on a schedule; pause, resume or run it once.

  • Skills & connectors

    Docs: Skills & connectors

    Switch the agent's skills and connected apps per account.

03MCP · Agents · CLI

Use Vife from your AI

Every API operation is an MCP tool. Your key decides which tools exist: a read-only key cannot change anything.

MCP server

https://api.vife.ai/v1/mcp

  • Streamable HTTP, stateless; the same key and limits as REST
  • One tool per operation, named by its operationId
  • A read-only key lists only the read tools
  • Writes take an idempotency_key argument for safe retries
MCP setup guide
claude mcp add --transport http vife https://api.vife.ai/v1/mcp \
  --header "Authorization: Bearer $VIFE_API_KEY"

Cursor reads .cursor/mcp.json (or ~/.cursor/mcp.json); VS Code reads .vscode/mcp.json and asks for the key once.

tools/list · one tool per operation
ToolFull keyRead-only key
createTask
getTask
sendTaskMessage
listTaskFiles
downloadFile
createAutomation
getAccount

Are you an AI agent?

Paste this into Claude Code, Cursor or any coding agent. It reads the docs and connects itself.

Read https://vife.ai/llms.txt and https://api.vife.ai/v1/openapi.json, then connect the Vife MCP server at https://api.vife.ai/v1/mcp with the header "Authorization: Bearer $VIFE_API_KEY". Use it to create Vife tasks and fetch the files they make.

The vife command line

Every API operation as a command, plus tasks wait, file upload and download, and webhook signature checks. Same key, same limits.

vife
npm install -g @vifeai/cli
vife auth login < key.txt
vife tasks create --mode slide --input "A launch deck for AURA"
vife tasks wait $TASK_ID
vife files download $FILE_ID --output launch-deck.pptx
CLI reference

04Lifecycle

Long tasks, handled

A task can research and build for a while. Creating one answers at once; then you follow it by webhook or by polling, and answer it when it asks.

queued202 on create
running
task.needs_inputPOST …/messages
needs_input
  • completedtask.completed
  • failedtask.failed
  • stoppedPOST …/stop
A task is queued, then running. It may wait in needs_input until you answer, and ends completed, failed or stopped.

Webhooks

push

Add an HTTPS endpoint in Settings › Developer. Vife posts task.completed, task.failed and task.needs_input for every task of your account, whatever started it.

Vife-Signature: t=…,v1=…Docs →

Polling

pull

Read the task again until its status settles. The answer carries the result text, the files and anything the task waits for.

GET /v1/tasks/{id}Docs →
  • Idempotent creates

    The same Idempotency-Key never starts a second task.

  • Signed deliveries

    Ten retries over about 40 hours, each attempt in a delivery log.

  • Stop at any time

    POST /v1/tasks/{id}/stop settles the run as stopped.

06Control

Built to run unattended

Keys you can scope, writes you can retry, events you can verify and limits you can read from every answer.

Limits and errors →
  • Full and read-only keys

    A read-only key reads and lists. Every write it tries answers 403 read_only_key.

    vife_sk_…
  • Idempotent writes

    Send Idempotency-Key on a POST. A repeat within 24 hours replays the first answer.

    Idempotency-Key
  • Signed webhooks

    HMAC-SHA256 over the timestamp and body. Ten retries over about 40 hours, and every attempt in a delivery log.

    Vife-Signature
  • Rate limits per key

    30 requests a minute per key on Free, 120 on a paid plan. Every answer carries the X-RateLimit headers.

    X-RateLimit-Remaining
  • Stop and share

    Stop a run at any time. Share a task's public link, or take it back.

    POST /v1/tasks/{id}/stop
  • Visible in your account

    A task from a key is an ordinary Vife task, with its transcript and files in the app.

    web_url

Pricing

Uses the credits you already have

There is no separate API price. A task started over the API spends the same Vife credits it would spend in the app.

See plans
One balance
API task
same credits as in the app
GET /v1/account
balance, plan and rate limits
credits.low
when the balance falls below 50

Resources

Everything in one place

  • Docs

    Quickstart, webhooks, MCP and every operation.

  • OpenAPI 3.1

    The machine-readable reference of the user API.

  • MCP endpoint

    https://api.vife.ai/v1/mcp

  • llms.txt

    The site index written for language models.

  • CLI

    The vife command for scripts and terminals.

Frequently asked questions

What is the Vife API?

It runs the same agent as vife.ai from your own code. You send a task with POST /v1/tasks, and the agent plans, researches, uses tools and returns the result as text and files. The same key also works with the MCP server.

How is it different from a model API?

A model API returns text for a prompt; search, tools, retries and file rendering are yours to build. The Vife API takes a task and returns the finished work: a deck, a document, a spreadsheet, images, video or audio, plus the transcript.

How is it billed?

API tasks spend your ordinary Vife credits, exactly as the same task would in the app. There is no separate API price. GET /v1/account shows the balance, and the credits.low webhook fires when it falls below 50 credits.

How long can a task run and how do I get the result?

Tasks are long-running by design: the create call answers 202 at once with status queued, and the task runs until it completes, fails, needs input or you stop it. Subscribe to the task.completed webhook, or poll GET /v1/tasks/{id}.

How do I get the files a task made?

A completed task lists its files in result.artifacts, each with a name, type, size and download url. GET /v1/tasks/{id}/files pages through all of them, and GET /v1/files/{id}/content redirects to the file.

Does it work with Claude Code, Cursor and other MCP clients?

Yes. https://api.vife.ai/v1/mcp is a remote MCP server over Streamable HTTP. Every API operation is a tool named by its operationId, and the key decides which tools exist: a read-only key only lists the read tools.

Can I schedule tasks?

Yes. POST /v1/automations creates an automation that runs a task on a schedule. You can pause, resume or run it once, read its runs, and receive automation.run.finished when a run ends.

I am an AI agent — how do I set up?

Read https://vife.ai/llms.txt and the OpenAPI 3.1 document at https://api.vife.ai/v1/openapi.json. Then connect the MCP server at https://api.vife.ai/v1/mcp with the header Authorization: Bearer and the key your person created in Vife › Settings › Developer.

POST /v1/tasks

Send your first task

Create a key, send one request and get a file back. Your existing Vife credits pay for it.

Are you an AI agent? See setup options