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

For most teams, the real blocker isn’t calling the Agent API (V1 Beta)—it’s getting from “I heard about MultiOn” to “I have a working X_MULTION_API_KEY and my first agent session running.” This guide walks through that full path: sign-up, API key creation, and a minimal test call so you can prove the integration end to end.

---

Overview: from account to first Agent API call

At a high level, you’ll move through four steps:

1. Create a MultiOn account
2. Verify access and reach the dashboard
3. Generate and securely store your X_MULTION_API_KEY
4. Use that key to call the Agent API (V1 Beta) with a minimal cmd + url workflow

Along the way, I’ll call out the exact headers, endpoints, and basic error states so you’re not guessing.

---

1. Create your MultiOn account

1. Open https://multion.ai in your browser.
2. From the homepage, follow the sign-up or “Get started” / “Get access” entry point to create an account.
3. Register using your work email (recommended for rate limiting and team access control).
4. Complete any email verification step sent to your inbox.

Once you’ve verified your email, you should be able to log into the MultiOn dashboard. That dashboard is where you’ll generate and manage your API keys.

If you’re joining as part of a team:
Align on a shared account or organization before you start issuing keys. It’s easier to rotate one org-level key than to chase down five “temporary” personal keys in production.

---

2. Confirm access to the Agent API (V1 Beta)

MultiOn exposes browser-operating agents via the Agent API (V1 Beta). You’ll use it to send high-level commands (like “search for a monitor and add the top result to cart”) and let the agent execute in a real browser session.

Before you create a key, confirm that your account has API access:

1. Log into the MultiOn dashboard.
2. Navigate to the API or Developer section (exact label may change, but look for something referencing API access or keys).
3. Check for:
   • A visible API Keys / Access Tokens panel, or
   • A prompt to request API access / join a beta program.

If you see an “apply for access” or “get early access” flow, complete the short form. Typically you’ll be asked for:

• Your company name
• Intended use case (e.g., agentic commerce, automation and internal tools, developer testing)
• A contact email

Once you’re approved, you’ll be able to generate keys and call endpoints like:

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

---

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

With access enabled, generate your API key:

1. In the dashboard, go to API Keys (or equivalent).
2. Click Create API Key / New Key.
3. Give the key a clear, scoped name, e.g.:
   • staging-agent-api-key
   • prod-web-agents
4. Confirm creation. The dashboard will display a secret token value.

This token is what you’ll pass as X_MULTION_API_KEY in your API calls.

Store the key securely

Treat this token like any other production secret:

• Do not commit it to Git.
• Store it in a secret manager (e.g., AWS Secrets Manager, GCP Secret Manager, Vault) or your CI/CD’s encrypted variables.
• In local development, use an .env file that’s excluded via .gitignore.

Example .env:

MULTION_API_KEY=sk_live_replace_with_your_real_key

---

4. Understand how the Agent API uses your key

MultiOn’s Agent API expects your key in a dedicated header:

X_MULTION_API_KEY: <your_api_key_here>

You’ll combine that with a JSON body that includes at least:

• cmd: what you want the agent to do
• url: the starting URL in a real browser session

Typical base endpoint:

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

MultiOn will execute your cmd in a secure remote session. For multi-step flows (e.g., Amazon add-to-cart then checkout), you’ll use Sessions + Step mode with a session_id returned from the first call.

---

5. Make your first test call with the new API key

Here’s a minimal “smoke test” to confirm your sign-up and API key are working.

Example: Node.js / TypeScript

Install a fetch client if you don’t already have one:

npm install node-fetch

Create test-multion-agent.js:

import fetch from 'node-fetch';

const API_KEY = process.env.MULTION_API_KEY;

async function main() {
  const res = await fetch('https://api.multion.ai/v1/web/browse', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X_MULTION_API_KEY': API_KEY,
    },
    body: JSON.stringify({
      url: 'https://www.amazon.com',
      cmd: 'Search for a USB-C hub and open the first product page.',
    }),
  });

  if (res.status === 402) {
    console.error('402 Payment Required: check your plan / billing status.');
    process.exit(1);
  }

  if (!res.ok) {
    console.error('Error from MultiOn:', res.status, await res.text());
    process.exit(1);
  }

  const data = await res.json();
  console.log('Agent response:', JSON.stringify(data, null, 2));
}

main().catch(err => {
  console.error('Request failed:', err);
  process.exit(1);
});

Run it:

MULTION_API_KEY=sk_live_replace_with_your_real_key node test-multion-agent.js

You should see a JSON response that includes:

• The agent’s interpretation of your cmd
• Details about the resulting page / actions taken
• A session_id you can reuse to continue the workflow

If you get an authentication error (4xx):

• Double-check the header name: it must be X_MULTION_API_KEY
• Verify the key was copied exactly (no extra whitespace)
• Ensure the key hasn’t been revoked or rotated in the dashboard

---

6. Use session_id for multi-step Agent API flows

The real value of MultiOn is long-lived, reliable sessions—not one-off fetches.

After your first web/browse call, you’ll typically receive a session_id. Use it to keep the same browser session alive across multiple steps (login, navigation, checkout).

Example 2-step pattern:

// Step 1: start session and search on Amazon
const startRes = await fetch('https://api.multion.ai/v1/web/browse', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X_MULTION_API_KEY': API_KEY,
  },
  body: JSON.stringify({
    url: 'https://www.amazon.com',
    cmd: 'Search for a 27 inch monitor and open the first result.',
  }),
});

const startData = await startRes.json();
const sessionId = startData.session_id;

// Step 2: continue in the same browser session
const stepRes = await fetch('https://api.multion.ai/v1/web/browse', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X_MULTION_API_KEY': API_KEY,
  },
  body: JSON.stringify({
    session_id: sessionId,
    cmd: 'Add this product to cart and proceed to checkout until the payment page.',
  }),
});

const stepData = await stepRes.json();
console.log('Checkout flow result:', JSON.stringify(stepData, null, 2));

This session continuity is what replaces the fragile selector choreography you’d otherwise maintain in Playwright/Selenium.

---

7. Common issues when generating and using API keys

A few failure patterns I’ve seen repeatedly:

7.1 “Invalid API key” or 401/403 responses

Check:

• Header name is exactly X_MULTION_API_KEY
• You’re not mixing up a sandbox/test key with a production-only endpoint
• The key hasn’t been deleted or rotated in the dashboard

If your org rotated keys, make sure your CI/CD secrets and .env are updated everywhere.

7.2 “402 Payment Required”

MultiOn explicitly returns 402 Payment Required in some billing states.

If your test call returns 402:

• Log into the dashboard
• Confirm you’re on a plan that includes Agent API usage
• Add billing details or adjust your plan if needed

Expect this as a normal part of the API contract, not a generic failure.

7.3 Local tests working, staging/prod failing

Usually caused by:

• Missing environment variables in your deployment environment
• Different key per environment, with one environment using a revoked key
• Network egress controls in your VPC blocking outbound requests to https://api.multion.ai

Confirm the effective value of X_MULTION_API_KEY in each environment (without logging the full key) and verify outbound connectivity.

---

8. Next: connect Agent API with Retrieve and the Chrome extension

Once you’ve signed up, generated an API key, and validated an end-to-end call, you can layer in the rest of the platform:

• Retrieve: Turn dynamic pages into structured JSON arrays of objects. Use controls like renderJs, scrollToBottom, and maxItems when you need to convert an H&M catalog or similar infinite scroll pages into fields like name, price, colors, urls, and images.
• Sessions + Step mode: Model full flows—Amazon ordering, posting on X, login + KYC steps—without wrestling selectors. The session_id is your unit of reliability.
• Chrome Browser Extension: Run “local” agent actions inside your own browser session (useful for debugging workflows before you fully automate them via the Agent API).

All of these surfaces rely on the same foundation you just set up: a valid MultiOn account and a correctly scoped X_MULTION_API_KEY.

---

Summary

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

1. Create and verify a MultiOn account at https://multion.ai.
2. Confirm you have API access in the dashboard (and request early/beta access if prompted).
3. Generate a new API key, name it by environment, and store it securely.
4. Use that key as X_MULTION_API_KEY in calls to endpoints like POST https://api.multion.ai/v1/web/browse.
5. Validate with a simple cmd + url test flow and then build out multi-step sessions using session_id.

Once this is in place, you can move from brittle scripts to intent-level commands executed in real, secure remote browser sessions—with structured JSON outputs where you need them.