How do I sign up for MultiOn and generate an API key for the Agent API (V1 Beta)?

If you want to move from brittle Playwright/Selenium scripts to intent-driven browser agents, the first step is getting a MultiOn account and an API key you can send as X_MULTION_API_KEY to the Agent API (V1 Beta). This guide walks through sign-up, key creation, and a quick verification call so you don’t waste time guessing whether your key actually works.

---

1. Understand what you’re signing up for

Before you create an account, it helps to know what the key is actually unlocking:

• Agent API (V1 Beta)
  Core endpoint for “intent in, browser actions out.” You send a cmd and url to something like:

  POST https://api.multion.ai/v1/web/browse
  

  authenticated with X_MULTION_API_KEY. The agent runs in a secure remote session and returns a session_id you can keep using in Step mode.

• Sessions + Step mode
  Keep long, multi-step flows alive—Amazon checkout, X posting, login + form + submit—without re-implementing brittle selector logic. The session_id is the unit of continuity.

• Retrieve for structured outputs
  Convert dynamic pages into JSON arrays of objects with controls like renderJs, scrollToBottom, and maxItems instead of rebuilding scrapers for each layout change.

The API key you generate will authorize all of this for your account.

---

2. Sign up for MultiOn

1. Go to the MultiOn website
   Open your browser and navigate to:
   https://multion.ai

2. Locate the sign-up / get started flow
   Look for a “Get started”, “Sign up”, or developer/console entry point. MultiOn is optimized for builders, so the primary CTA will route you into the developer side rather than a consumer interface.

3. Create your account

   • Use your work email if you’re planning to embed MultiOn into a product or internal tool.
   • Complete any email verification step so you can access API settings later.
   • Optionally add basic org details (company name, team size, intended use) if prompted. This helps MultiOn route you correctly if there are tiered limits or early-access flags on certain features.

4. Sign in to the developer console Once registration is complete and verified:

   • Log in with the account you just created.
   • You should land in a dashboard or console view—this is where API keys, usage, and billing live.

If you can’t find a console or keys area from the main UI, check for navigation items like “Developers,” “API,” “Agent API,” or “Settings.”

---

3. Navigate to API keys in the dashboard

Within the MultiOn console, you’re looking for the page that manages credentials:

1. Open account or organization settings
   Common labels:

   • Settings
   • Developers
   • API Keys
   • Security or Access

2. Locate the API / Agent access section
   You should see:

   • A list of existing keys (if any)
   • A button like “Create API key”, “New key”, or “Generate token”
   • Key metadata such as name, created date, last used, scopes, or status

If the Agent API (V1 Beta) is gated as early access, there might be an additional toggle or application step (e.g., enabling the Agent API for your project). Complete that before attempting to call the endpoints.

---

4. Generate an API key for the Agent API (V1 Beta)

Create a key with clear intent and minimal blast radius. This isn’t another “throwaway personal token”—it will control real browser sessions that can log in, order, and post.

1. Click “Create API key” / “New key”

2. Name the key by use case Examples that age well in production:

   • prod-agent-api-backend
   • staging-agent-api-web-browse
   • internal-tools-amazon-ordering

3. Scope / permissions (if available) If the console lets you choose scopes:

   • Include: Agent/Browser actions (Agent API V1 Beta), Retrieve/data extraction.
   • Exclude anything your service doesn’t need yet. This keeps audits and eventual key rotation simpler.

4. Environment separation

   • Generate separate keys for dev/staging vs production.
   • Never reuse a prod key in local demos or throwaway scripts.

5. Confirm and create The console will generate a token string—this is your API secret.

---

5. Store your MultiOn API key securely

Treat X_MULTION_API_KEY like database credentials, not like a test cookie.

• Copy the key once
  Many consoles will only show the raw token on creation. Copy it to a secure place immediately.

• Use environment variables, not hard-coded strings

  • For Node:

    # .env
    MULTION_API_KEY=sk_your_real_key_here
    

    // app.ts
    const apiKey = process.env.MULTION_API_KEY;
    

  • For serverless / containers: set MULTION_API_KEY in your platform’s secrets manager.

• Never expose keys in the frontend

  • Do not ship the key in browser JavaScript or mobile apps.
  • Instead, have your backend call MultiOn (Agent API, Retrieve) and expose only your own application’s endpoints to clients.

• Rotate and revoke keys when needed Use the console to:

  • Revoke keys that are no longer needed.
  • Rotate keys on a schedule or after staff changes.

---

6. Verify your API key with a minimal Agent API call

Before wiring MultiOn into a complex workflow, confirm your key works with a simple, reproducible request.

6.1. Install the SDK (if available) or use raw HTTP

For Node.js, a typical pattern is:

npm install multion

If you’re not using an SDK, you can call the API directly with fetch, axios, curl, or your HTTP client of choice.

6.2. Send a basic web/browse command

This pattern checks:

• Authentication via X_MULTION_API_KEY
• That Agent API (V1 Beta) is enabled for your account
• That you can receive a valid session_id for step-based workflows

Example with curl:

curl -X POST https://api.multion.ai/v1/web/browse \
  -H "Content-Type: application/json" \
  -H "X_MULTION_API_KEY: $MULTION_API_KEY" \
  -d '{
    "url": "https://www.amazon.com",
    "cmd": "Open the homepage and summarize what you see."
  }'

You should see a response shaped roughly like:

{
  "session_id": "sess_123...",
  "status": "success",
  "result": {
    "summary": "..."
  }
}

Save that session_id. It’s what you’ll reuse for Step mode to continue the same browser session (e.g., search → add to cart → checkout).

6.3. Interpreting common errors

• 401 Unauthorized / 403 Forbidden
  • The key is invalid, revoked, or missing.
  • Check that:
    • You’re sending X_MULTION_API_KEY, not a different header name.
    • The value matches exactly what was generated in the console.
• 402 Payment Required
  • MultiOn is explicitly telling you the account is not allowed to proceed under current billing or quota.
  • Fix: update billing or adjust your plan in the console.
• 4xx with feature-specific message
  • Might indicate Agent API (V1 Beta) is not enabled for this project or key’s scope.

Once you get a successful response, you know your account + key + Agent API configuration are wired correctly.

---

7. Next: connect sessions and Retrieve to real workloads

With a valid key in hand, you can move from “hello world” to actual web automation.

7.1. Use Sessions + Step mode for multi-step flows

Pattern:

1. Initial call:

   POST /v1/web/browse
   

   • Inputs: url, cmd
   • Output: session_id, browser state

2. Subsequent steps (same session_id):

   POST /v1/web/step
   

   • Inputs: session_id, next cmd (e.g., “search for ‘wireless mouse’”, “add the first result to cart”, “go to checkout”)
   • Output: updated state, ability to continue

By storing and reusing the session_id in your backend, you replace brittle selector chains with high-level commands while MultiOn handles session continuity, secure remote browsers, and native proxy support for tricky bot protection.

7.2. Use Retrieve to turn dynamic pages into JSON

When you don’t need to act, only to extract:

POST https://api.multion.ai/v1/web/retrieve

Example body:

{
  "url": "https://www2.hm.com/en_us/men/products/jackets-coats.html",
  "renderJs": true,
  "scrollToBottom": true,
  "maxItems": 50,
  "schema": {
    "type": "array",
    "items": {
      "type": "object",
      "properties": {
        "name": { "type": "string" },
        "price": { "type": "string" },
        "colors": { "type": "array", "items": { "type": "string" } },
        "url": { "type": "string" },
        "image": { "type": "string" }
      },
      "required": ["name", "price", "url"]
    }
  }
}

The response will be a JSON array of objects matching your schema, without you writing custom scrapers or managing headless browser farms.

---

8. Operational best practices for your new API key

Once your MultiOn key is live against the Agent API (V1 Beta), protect yourself from the operational pain I’ve seen teams hit with homegrown automation stacks:

• Quota-aware design

  • Use the console to monitor usage and set alerts.
  • Avoid firing dozens of parallel agents from local scripts against a low-quota key; use this only in controlled environments.

• Per-service keys

  • Give each microservice or internal tool its own API key so you can revoke/rotate without collateral damage.

• Audit and logging

  • Log which service called MultiOn, with which session_id, and for what high-level task (e.g., amazon_checkout, x_post_publisher).
  • Never log raw API keys.

• Safe retries

  • If you retry on transient errors, reuse the same session_id when appropriate to avoid splitting workflows and doubling side effects.

---

Summary

To sign up for MultiOn and generate an API key for the Agent API (V1 Beta), you:

1. Create an account at https://multion.ai and access the developer console.
2. Navigate to API keys or Developer settings.
3. Generate a clearly named, scoped API key for your Agent API workflows.
4. Store it securely (environment variables, secrets manager; never in frontend code).
5. Verify it with a minimal POST https://api.multion.ai/v1/web/browse call, authenticated via X_MULTION_API_KEY.
6. Use the returned session_id with Sessions + Step mode and pair it with Retrieve for structured JSON from real, dynamic pages.

Once this is in place, you can stop babysitting fragile Playwright/Selenium suites and start treating “browser actions” as a backend capability—intent in, actions executed in a secure remote session, structured JSON out.