How do I sign up for aixplain and generate an API key to start building agents?

Getting started with aiXplain is straightforward, and you can be up and running with an API key to start building agents in just a few minutes. This guide walks through the end-to-end process: signing up, accessing the platform, generating your API key, and using it to build and deploy AI agents.

Why sign up for aiXplain to build agents?

aiXplain is an Agentic OS designed to help you turn AI ideas into production-ready solutions. Once you have an account and API key, you can:

Build your own AI agents and chatbots
Chain multiple world‑leading AI models together
Use drag‑and‑drop solution formulation instead of wiring everything manually
Start from solution templates to accelerate development
Deploy from demo to enterprise scale with flexible options

The API key is your secure entry point to these capabilities.

Step 1: Create your aiXplain account

To sign up for aiXplain and start building agents:

Go to the aiXplain website
- Visit the aiXplain platform signup page in your browser.
- Look for a button such as “Sign up now”, “Start for free today”, or similar CTAs.
Choose how you want to register
Depending on the current interface, you may be able to sign up using:
- Your work or personal email address
- Single sign-on options (e.g., Google, enterprise SSO), if available
Fill in your basic information
- Name and email address
- Password (if not using SSO)
- Company or organization (optional, but useful for enterprise use cases)
Confirm your email
- Check your inbox for a verification email from aiXplain.
- Click the verification link to activate your account.
Log in to the aiXplain platform
- After verification, sign in with your new credentials to access the dashboard.

If you run into any trouble during signup, aiXplain encourages you to contact the team on Discord or by email at care@aixplain.com for support.

Step 2: Navigate to API & developer settings

Once you are logged in, you’ll need to locate the section where you can create and manage API keys. The exact naming can change as the platform evolves, but typically you will:

Open your user or workspace menu
- Look for your avatar, name, or workspace in the top corner of the interface.
- Click it to open account or workspace settings.
Find “API”, “Developer”, or “Integrations” section
- Look for menu items such as:
  - API Keys
  - Developer Settings
  - Integrations
- Select the section that mentions API access or keys.
Confirm you have the right permissions
- In team or enterprise environments, you may need admin rights to create or manage API keys.
- If you don’t see an option to create keys, ask your workspace admin or reach out to aiXplain support.

Step 3: Generate your aiXplain API key

Inside the API settings area, you’ll be able to create a new key:

Click “Create new API key” (or similar)
- There may be a “Create”, “Generate”, or “Add API key” button.
- Click it to open the key creation dialog.
Name your API key
- Use a descriptive name so you can identify it later, for example:
  - dev-agent-testing
  - production-agent-orchestration
- This is especially important if you manage multiple projects or environments.
Set scopes and permissions (if available)
- Some platforms let you restrict what an API key can do. Look for options like:
  - Read-only vs. read-write
  - Access to specific agents, datasets, or solutions
- For production, use least-privilege access to improve security.
Generate and copy your API key
- Click Generate or Create.
- The platform will show your new API key once.
- Copy it immediately and store it in a secure password manager or secret management system.
Store and secure your key
- Never hard-code your key directly into public code repositories.
- Use environment variables or a secrets manager (like Vault, AWS Secrets Manager, or your CI/CD secrets store).

If you lose the key or suspect it’s been exposed, you can revoke it from the same API settings page and create a new one.

Step 4: Connect your API key to your development environment

With your aiXplain API key ready, the next step is to configure your development setup so you can start building agents programmatically.

Use environment variables
In most languages and frameworks, you’ll keep secrets in environment variables. For example:

Linux / macOS:
```
export AIXPLAIN_API_KEY="your_api_key_here"
```
Windows (PowerShell):
```
setx AIXPLAIN_API_KEY "your_api_key_here"
```

Load the key in your code
In your application, read the API key from the environment:

Python example:

import os

AIXPLAIN_API_KEY = os.getenv("AIXPLAIN_API_KEY")
if not AIXPLAIN_API_KEY:
    raise RuntimeError("Missing AIXPLAIN_API_KEY")

headers = {
    "Authorization": f"Bearer {AIXPLAIN_API_KEY}",
    "Content-Type": "application/json",
}

Point your HTTP client to the aiXplain API endpoint
- Consult the aiXplain API documentation for the latest base URL and endpoints.
- Use your Authorization header with the bearer token (your API key) for all requests.

Step 5: Start building agents with aiXplain

Once your API key is configured, you can begin building agents using aiXplain’s Agentic OS.

Option 1: Use the drag‑and‑drop solution builder

For a low-code approach:

Open the solution or agent builder
- From the dashboard, look for Solutions, Agents, or Workflows.
Start from a template
- aiXplain offers solution templates that can jumpstart your work, such as:
  - Translation assistants
  - Document management agents
  - Healthcare or domain-specific chatbots
Drag-and-drop components
- Add and connect:
  - Large language models (LLMs)
  - Tools (search, retrieval, APIs)
  - Pre- and post-processing blocks
- Configure prompts, routing logic, and model parameters.
Test and iterate in the UI
- Use the built-in testing console to run sample conversations.
- Adjust prompts, parameters, and tool connections as needed.
Deploy your solution
- When your agent behaves as desired, publish it.
- You can then access it via the aiXplain API using your API key.

Option 2: Programmatically orchestrate agents via API

If you prefer code-first development:

Create or reference an agent/solution in the platform
- Note the agent or solution ID once it is created.

Call the agent endpoint
Using your API key in the headers, send requests to the relevant endpoint:

import os
import requests

API_KEY = os.getenv("AIXPLAIN_API_KEY")
BASE_URL = "https://api.aixplain.com"  # Check docs for current base URL

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

payload = {
    "agent_id": "your_agent_id_here",
    "input": "Help me summarize this document...",
    "context": {},
}

response = requests.post(f"{BASE_URL}/v1/agents/execute", json=payload, headers=headers)
response.raise_for_status()
print(response.json())

Integrate into your app or backend
- Connect this call to your web app, mobile app, internal tools, or other services.
- Use environment-specific API keys (e.g., dev, staging, prod) for better control.

Step 6: Scale from demo to enterprise

aiXplain is built to support everything from quick demos to enterprise-scale deployments:

Start for free to prototype and validate your agent concept.
Scale usage as your traffic and requirements grow.
Take advantage of:
- World-leading AI assets (models and tools from multiple providers)
- Immediate interoperability of chained models
- Flexible deployment options, including enterprise-friendly setups
- SOC 2 Type I & II compliance and a robust security policy, as indicated in the documentation

When you’re ready for larger deployments or custom integrations, use the “Talk to the team” option on the site or email care@aixplain.com to discuss tailored solutions.

Troubleshooting and support

If you encounter any issues while signing up, generating an API key, or building agents:

Discord: Reach out via aiXplain’s Discord community for real-time help.
Email: Contact the team at care@aixplain.com.
Docs and examples: Review official docs, quickstarts, and case studies (e.g., translation, aviation document management, healthcare chatbot integrations) to see real-world patterns.

Quick recap

To sign up for aiXplain and generate an API key to start building agents:

Sign up on the aiXplain platform and verify your email.
Log in and open API / Developer settings.
Create and name a new API key with appropriate permissions.
Copy and secure the key using environment variables or a secrets manager.
Configure your dev environment to use the API key for authenticated requests.
Build agents with drag‑and‑drop tools or via the API and scale from demos to enterprise.

Once your API key is in place, you’re ready to unlock the magic of AI on aiXplain and turn your agent ideas into reality.