Skip to main content
Agent profiles in Asteroid provide a way to create consistent, reusable browser automation environments. Each profile contains configuration settings for proxies and captcha solving along with associated credentials for authentication across different websites and services.

Quick Start

1

Create an Agent Profile

Use the Asteroid dashboard to create a new agent profile with your desired proxy settings, captcha solver configuration, and automation features. You can also create profiles via the API and SDKs:
2

Add Credentials (Optional)

If your automation requires authentication, add credentials to your profile through the dashboard’s credential management interface.
3

Execute with Profile

Execute your agent using the profile through either the dashboard or SDK:
  1. Navigate to the Agents section in your Asteroid dashboard
  2. Select the agent you want to execute
  3. Choose your created profile from the dropdown next to Run Agent
  4. Provide your input data and click Run
  5. Monitor the execution progress in real-time

Agent Profiles

Agent profiles define the browser automation environment settings that will be used during execution. These profiles ensure consistent behavior across different automation runs and provide isolation between different use cases.

Profile Configuration

Each agent profile contains the following key components:
  • Proxy Country Code: Two-letter lowercase country code for proxy location (e.g., “us”, “uk”, “de”)
  • Proxy Type: Type of proxy connection to use
  • Persistent IP: Whether to maintain the same IP address across requests
    Persistent IP’s can only be used with a US proxy and do not support Mobile proxies or Captcha Solving
  • Captcha Solver: Enable/disable automatic captcha solving capabilities
  • Cookies: Profiles can preload and persist site cookies. You can create profiles with cookies, and add/remove cookies later via the SDK. Useful for keeping authenticated sessions or site preferences.
  • Cache Persistence: Control whether browser cache and cookies are retained between executions. When enabled (default), the profile maintains session state, cookies, and cached data across runs for seamless continuity. When disabled, each execution starts with a fresh browser state. Cache can be manually cleared at any time using the “Clear Cache” option.
Agent profiles can be created and managed through the dashboard, the API, and SDKs. See Create an agent profile, TypeScript SDK, and Python SDK.
Deleting a profile will affect any executions that reference it. Ensure no active automations depend on the profile before deletion.

Credentials Management

Store credentials securely by linking them to an agent profile. In the Vault section, enter the credential name and value. Your agent will have access to these credentials automatically, but if you want to reference credentials in prompts, use their capitalized name between hashes (e.g. ##PASSWORD##). For more information, see Security.
Never expose your credentials in a prompt

Profile Pools

Profile pools allow you to group multiple agent profiles together so the system automatically selects one at execution time. Instead of manually choosing a single profile for each execution, you point to a pool and Asteroid picks the best available profile for you.
Profile pools can be created and managed through the dashboard, the API, and SDKs. See the API reference: Create a pool, List pools, Update a pool, Manage members.

Why Use Profile Pools?

Profile pools solve common challenges in browser automation:
  • Avoid credential conflicts: Prevent simultaneous use of the same account across multiple executions
  • Distribute load: Spread requests across multiple accounts to respect rate limits
  • Improve reliability: Automatically use alternative profiles when one is unavailable
  • Reduce friction: Eliminate manual profile selection for each execution
Think of profile pools as a “rotation strategy” for your automation credentials. Rather than hard-coding a specific profile, you define a pool of profiles and let the system intelligently choose which one to use.

Selection Strategies

Profile pools support two selection strategies that determine which profile gets picked for each execution:
Selects the profile that hasn’t been used for the longest time. This distributes load evenly across all profiles in the pool.Best for:
  • Spreading requests across accounts to avoid rate limits
  • Rotating through multiple accounts fairly
  • Scenarios where you want to minimize repeated use of the same profile
Example: If you have profiles A, B, and C, and the last execution used profile B, the next execution will prefer profile A (if it was used longest ago), then C, then B.
Selects the most recently used profile. This concentrates activity on fewer “warm” profiles.Best for:
  • Keeping sessions warm and browser state cached
  • Reusing authenticated sessions when possible
  • Scenarios where session continuity matters more than distribution
Example: If profile B was just used successfully, the next execution will try to use profile B again to maintain session state.

Concurrent Use Control

Control whether a profile can be selected while it’s already being used by another running execution:
  • allowConcurrentUse: false (default) — A profile that is currently tied to an active execution will be skipped. If all profiles in the pool are busy, the execution request fails immediately.
    • Best for: Strict credential isolation where you never want the same account used simultaneously
    • Use when: The target site enforces per-session limits or you need guaranteed isolation
  • allowConcurrentUse: true — Any profile can be selected regardless of whether it’s currently in use by another execution.
    • Best for: High-throughput scenarios where the target site doesn’t enforce strict per-session limits
    • Use when: You want maximum availability and don’t need credential isolation
If allowConcurrentUse is set to false and all profiles in the pool are currently in use, new execution requests will fail with an error indicating no profiles are available. Consider adding more profiles to your pool or enabling concurrent use.

Quick Start

1

Create a Pool

Create a new profile pool via the platform or programmatically:
  1. Navigate to Agent Profiles in your Asteroid dashboard
  2. Click Create Profile Pool
  3. Provide a unique name for your pool
  4. Choose your selection strategy (Least Recently Used or Most Recently Used)
  5. Configure concurrent use setting
  6. Click Create
2

Add Profiles to the Pool

Select existing agent profiles to include in your pool:
  1. Open your newly created profile pool
  2. Click Add Profiles
  3. Select the agent profiles you want to include
  4. Click Add to Pool
3

Execute with the Pool

Use the pool ID when triggering an execution instead of specifying a profile ID:
  1. Navigate to your agent
  2. Click Run Agent
  3. Select your profile pool from the dropdown (instead of a single profile)
  4. Provide your input data and click Run
  5. The system will automatically select an available profile from the pool

Important Constraints

The agent_profile_id and agent_profile_pool_id parameters are mutually exclusive. You must specify one or the other, but not both.Correct:
// Use a single profile
{ agent_profile_id: 'profile-123' }

// OR use a pool
{ agent_profile_pool_id: 'pool-456' }
Incorrect:
// Cannot specify both
{
  agent_profile_id: 'profile-123',
  agent_profile_pool_id: 'pool-456'  // ❌ Error
}
  • All profiles in a pool must belong to the same organization
  • Pool names must be unique within an organization
  • Profiles cannot be added to pools from different organizations
  • A pool must contain at least one profile to be used for executions
  • If allowConcurrentUse is false and all profiles are in use, execution requests will fail
  • Removing the last profile from a pool will prevent new executions from using that pool
Profile pools work seamlessly with all profile features including credentials, cookies, TOTP secrets, and cache persistence. The selected profile’s configuration applies to the execution as if you had manually chosen that specific profile.

2FA - TOTP Secrets

Set up Two-Factor Authentication (2FA) using Time-based One-Time Passwords (TOTP) with our TOTP tool. Asteroid supports all standard TOTP providers including Google Authenticator, Microsoft Authenticator, Authy, 1Password, and others.
TOTP provides an additional layer of security by generating time-based codes that expire after 30 seconds. This prevents unauthorized access even if your password is compromised. Our TOTP tool works with any service that provides a standard TOTP secret key.
1

Obtain TOTP Secret Key

Get your TOTP secret key from your service provider. The process varies by provider:Google Account:
  1. Navigate to your Google AccountSecurity
  2. Go to 2-Step VerificationAuthenticator appSet up authenticator
  3. Click Can’t scan it? to reveal the 32-character setup key
Other Popular Services:
  • Microsoft Authenticator: Microsoft Account → Security → Advanced security options → Add sign-in method
  • GitHub: Settings → Password and authentication → Two-factor authentication → Set up using an app
  • AWS: IAM Console → Users → Security credentials → Assign MFA device
  • Discord: User Settings → My Account → Enable Two-Factor Auth
  • Most Services: Look for “manual entry”, “can’t scan”, or “setup key” options that reveal the secret key
  • The key is typically a 16-32 character alphanumeric string (Base32 encoded)
2

Create TOTP Secret in Vault

In your Agent Profile’s Vault, create a new TOTP Secret credential and paste the secret key as the credential value. You can name your credential anything as long as it has the prefix TOTP_.
3

Add TOTP Tool to Agent

Add the Generate TOTP Secret tool to the agent node where you want to use TOTP.
4

Test Configuration

Execute your agent with the configured profile.

Cookies on Agent Profiles

Profiles can store website cookies to persist authenticated sessions and preferences across runs. Add cookies when creating a profile, or manage them later via the API.
type Cookie = {
  id?: string;       // present on existing cookies
  name: string;      // display name
  key: string;       // cookie name
  value: string;     // cookie value
  domain: string;    // e.g. '.example.com'
  secure: boolean;
  http_only: boolean;
  same_site: 'Strict' | 'Lax' | 'None';
  expiry?: string;   // ISO 8601
  created_at: string; // ISO 8601
}

SDK Methods

See the SDK for creation and management details: TypeScript SDK and Python SDK. The Asteroid SDK provides a simple interface for using agent profiles during execution:
import { AsteroidClient, executeAgent } from 'asteroid-odyssey';

const client = AsteroidClient('YOUR_API_KEY');

// Execute an agent with a specific profile
const executionId = await executeAgent(client, 'YOUR_AGENT_ID', {
    dynamic_data: {
        key: 'value'
    },
    agent_profile_id: 'YOUR_AGENT_PROFILE_ID'
});

Troubleshooting

Error: Agent profile not foundCauses:
  • Profile was deleted
  • Incorrect profile ID or name
  • Profile belongs to different organization
Solutions:
  • Verify the profile ID/name is correct
  • Check organization access permissions
  • Use the list profiles API to confirm available profiles

For additional help with agent profiles and credentials, consult the SDK documentation or contact our support.