Waymore Docs
Everything you need to integrate and use the LLM Portal platform.
/v1/messages — point the Anthropic SDK at https://chat.waymore.ai. See Migrate from Claude.Reference documentation, live examples, and platform policies—all in one place. Authenticate, select a model, and ship in minutes.
Base URL
https://chat.waymore.ai/v1
REST + SSE endpoints
Authentication
API keys & SSO
Bearer keys · Google · GitHub
API formats
OpenAI & Anthropic
/v1/chat/completions · /v1/messages
Security
TLS + HSTS
Strict security headers enforced
Status
Live status page
chat.waymore.ai/status
SDKs
OpenAI & Anthropic SDKs
Node.js · Python · REST + SSE
Rate limits
Up to 6,000 RPM
Plan-based: 600–6,000 requests/min
Support
Community to dedicated
Varies by plan
Get up and running with LLM Portal in a few simple steps. Use the hosted chat or integrate via REST.
Prerequisites
Create an account, verify email, and issue your first API key.
Recommended
Install the CLI or SDK to manage keys and sessions locally.
Step 1
Sign up at https://chat.waymore.ai/register or use Google/GitHub SSO, then verify your email.
Step 2
You're dropped into the chat UI with streaming answers, conversation history, and ratings out of the box.
Step 3
Visit the API Keys page, issue a scoped key, and copy it immediately — it is only shown once.
Step 4
Use the OpenAI-compatible endpoint and the language tabs below to test.
| 1 | curl https://chat.waymore.ai/v1/chat/completions \ |
| 2 | -H "Authorization: Bearer YOUR_API_KEY" \ |
| 3 | -H "Content-Type: application/json" \ |
| 4 | -d '{ |
| 5 | "model": "Waymore-A1-Instruct-1011", |
| 6 | "messages": [ |
| 7 | {"role": "user", "content": "Hello, how are you?"} |
| 8 | ] |
| 9 | }' |
| 1 | { |
| 2 | "id": "chatcmpl-abc123", |
| 3 | "model": "Waymore-A1-Instruct-1011", |
| 4 | "choices": [ |
| 5 | { |
| 6 | "message": { |
| 7 | "role": "assistant", |
| 8 | "content": "Hello! I'm doing well, thank you for asking. How can I help you today?" |
| 9 | }, |
| 10 | "finish_reason": "stop" |
| 11 | } |
| 12 | ], |
| 13 | "usage": { |
| 14 | "prompt_tokens": 12, |
| 15 | "completion_tokens": 18, |
| 16 | "total_tokens": 30 |
| 17 | } |
| 18 | } |
Your terminal coding agent — powered by WayMore AI. Code, debug, and ship from the command line.
Best for
Developers who prefer the terminal for AI-assisted coding and task automation.
Highlights
One-line install, automatic PATH setup, in-place upgrades.
Install with a single command. The installer downloads the latest binary and configures your shell automatically.
| 1 | curl -fsSL https://cdn13.waymore.io/cdn/waymore/install.sh | sh |
The binary is placed at ~/.local/bin/waymore (or /usr/local/bin/waymore with sudo).
Shell rc files (~/.zshrc, ~/.bashrc, ~/.bash_profile) are updated automatically.
Open a new terminal window after installing, then run:
| 1 | waymore --version |
Run waymore login. The CLI prints a short code and a URL, and waits.
| 1 | waymore login |
Open chat.waymore.ai/cli-auth in a browser, sign in if you are not already, check that the device shown matches the machine you are sitting at, and approve it. The CLI picks up the approval within a few seconds and stores its credentials — there is nothing to copy and paste.
The code is valid for 10 minutes. If it expires, run waymore login again.
Approving creates an API key named WayMore CLI — <your device name>, visible
alongside your other keys in the dashboard. Revoking that key signs the device
out.
Each machine you approve counts as one device against your plan: 3 on Free and
Lite, up to 20 on Ultimate — the full table is in
Billing & Plans. Signing in on a new machine while at the limit
fails with device_limit_reached; revoke a key you no longer use, or move up a
tier.
An administrator can also block an individual device, which fails with
device_blocked. That one survives re-pairing — signing in again will not clear
it, so contact whoever administers your account.
The installer above auto-detects your platform and architecture, downloads the
latest build, verifies its SHA256 and installs to ~/.local/bin — it is the
recommended route. If you need the binary directly (air-gapped machines, custom
provisioning, container images), these links always serve the current release:
| OS | Download |
|---|---|
| Linux (x86_64) | waymore-x86_64-latest |
| Linux (arm64) | waymore-aarch64-latest |
| macOS (Apple Silicon) | waymore-aarch64-latest |
| macOS (Intel) | waymore-x86_64-latest |
| Windows (x86_64) | waymore-x86_64-latest.exe |
Downloading directly skips the checksum verification the installer performs, so
verify against the release manifest if integrity matters for your use case. On
macOS and Linux you will also need to mark the binary executable (chmod +x).
Prefer a desktop app? See WayMore Vibe.
The release manifest names the current version and, for each platform, the exact URL, SHA256 and byte size of that release:
| 1 | curl -s https://cdn13.waymore.io/cdn/waymore/manifest.json | jq '.platforms["linux-x86_64"]' |
| 2 | shasum -a 256 waymore-x86_64-latest |
Platform keys are linux-x86_64, linux-aarch64, darwin-aarch64,
darwin-x86_64 and windows-x86_64.
The -latest links move with every release. For reproducible builds — container
images, provisioning scripts, locked-down environments — use the version-pinned
form instead, which never changes once published:
| 1 | https://cdn13.waymore.io/cdn/waymore/linux/waymore-x86_64-1.44.37 |
| 2 | https://cdn13.waymore.io/cdn/waymore/linux/waymore-aarch64-1.44.37 |
| 3 | https://cdn13.waymore.io/cdn/waymore/macos/waymore-aarch64-1.44.37 |
| 4 | https://cdn13.waymore.io/cdn/waymore/macos/waymore-x86_64-1.44.37 |
| 5 | https://cdn13.waymore.io/cdn/waymore/windows/waymore-x86_64-1.44.37.exe |
Read latest_version from the manifest to find the current release number.
Re-run the same install command to upgrade in place. The direct links above are unversioned and always point at the current release, so re-downloading updates too.
With the CLI installed and signed in, run it inside a project directory:
| 1 | cd ~/code/my-project |
| 2 | waymore |
| 3 | |
| 4 | # Every command and flag |
| 5 | waymore --help |
The desktop coding agent — the same agent as the WayMore CLI, in a graphical app rather than a terminal.
WayMore Vibe is the desktop application for WayMore AI — the same coding agent as the WayMore CLI, in a graphical app rather than a terminal.
Vibe is included in every subscription plan, alongside the CLI and the web app.
All links are stable "always-latest" URLs — they always serve the current release, so you can bookmark them or reuse them in provisioning scripts.
| Format | Download |
|---|---|
| MSI installer | WayMore-Vibe-latest-x86_64.msi |
| Setup executable | WayMore-Vibe-latest-x86_64-setup.exe |
| Format | Download |
|---|---|
| Apple Silicon (M1 and later) | WayMore-Vibe-latest-aarch64.dmg |
| Intel | WayMore-Vibe-latest-x86_64.dmg |
If you are unsure which Mac you have, click the Apple menu → About This Mac. A "Chip" entry starting with Apple means Apple Silicon; a "Processor" entry naming Intel means Intel.
| Format | Download |
|---|---|
| AppImage — x86_64 (any distribution) | WayMore-Vibe-latest-x86_64.AppImage |
| AppImage — arm64 (any distribution) | WayMore-Vibe-latest-aarch64.AppImage |
| Debian / Ubuntu — x86_64 | WayMore-Vibe-latest-x86_64.deb |
| Debian / Ubuntu — arm64 | WayMore-Vibe-latest-aarch64.deb |
| Fedora / RHEL — x86_64 | WayMore-Vibe-latest-x86_64.rpm |
| Fedora / RHEL — arm64 | WayMore-Vibe-latest-aarch64.rpm |
Not sure which you need? Run uname -m — x86_64 means the x86_64 build,
aarch64 (or arm64) means the arm64 one.
The AppImage needs no installation — mark it executable and run it:
chmod +x WayMore-Vibe-latest-x86_64.AppImage
./WayMore-Vibe-latest-x86_64.AppImage
Vibe needs glibc 2.34 or newer, the same on both architectures, plus GTK 3
and WebKit2GTK 4.1. Check yours with ldd --version.
| Distribution | Works |
|---|---|
| Ubuntu | 22.04 LTS and newer |
| Debian | 12 (bookworm) and newer |
| Fedora | 35 and newer |
| RHEL, Rocky, AlmaLinux | 9 and newer |
| openSUSE | Tumbleweed, or Leap 16 and newer |
| Arch, and other rolling releases | yes |
Ubuntu 20.04, Debian 11, RHEL 8 and openSUSE Leap 15.x ship glibc 2.28–2.31 and are too old to run Vibe.
The .deb and .rpm declare this requirement, so on a system that is too old
apt or dnf refuses the install and tells you why.
The AppImage carries no such metadata. It will download and run on any
distribution, and on one below 2.34 it exits immediately with a message about
GLIBC_2.34 not being found — that is this requirement, not a corrupt download.
On a distribution that is too old, use the WayMore CLI instead: it needs only glibc 2.17 on arm64 and 2.14 on x86_64, which every distribution above comfortably exceeds.
| Format | Download |
|---|---|
| APK (sideload) | WayMore-Vibe-latest.apk |
The Android build is distributed as a sideloadable APK rather than through the Play Store, and it is signed with a debug key — Android will warn that it comes from an unknown developer, and you have to allow installs from whichever app you downloaded it with. It has no auto-updater: download the APK again to upgrade.
Requires Android 6.0 (API 23) or newer. Unlike the desktop downloads there
is no architecture to choose: the APK carries all four (arm64-v8a,
armeabi-v7a, x86, x86_64), so it installs on any phone, tablet or emulator.
It asks for two permissions — INTERNET and ACCESS_NETWORK_STATE — plus one
it defines for its own components. All three are granted at install; Android
never prompts for them. It requests no access to your camera, microphone,
location, contacts, photos or files.
On Windows, macOS and the Linux AppImage, Vibe checks for a new release and
updates itself in place — you do not need to download anything again. The
.deb, .rpm and Android builds sit outside that updater; upgrade those by
downloading the current file and reinstalling over the top.
Every download link above has a version-pinned twin: replace latest with a
release number and the URL is permanent, so it keeps serving that exact build
after later releases ship.
https://cdn13.waymore.io/cdn/waymore/vibe/windows/WayMore-Vibe-1.44.37-x86_64.msi
https://cdn13.waymore.io/cdn/waymore/vibe/macos/WayMore-Vibe-1.44.37-aarch64.dmg
https://cdn13.waymore.io/cdn/waymore/vibe/linux/WayMore-Vibe-1.44.37-x86_64.AppImage
https://cdn13.waymore.io/cdn/waymore/vibe/linux/WayMore-Vibe-1.44.37-aarch64.AppImage
Not every format is published for every release — the .deb and .rpm packages
in particular are cut less often than the AppImage. If a pinned URL 404s, that
format was not built for that version; use the release manifest below to find one
that was.
The Vibe release manifest lists the current version plus the URL, SHA256 and byte size of each installer:
curl -s https://cdn13.waymore.io/cdn/waymore/vibe-manifest.json | jq '.platforms["windows-x86_64"]'
shasum -a 256 WayMore-Vibe-latest-x86_64.msi
The manifest tracks one installer per platform — both Linux AppImages, both
macOS DMGs and the Windows MSI. The .deb, .rpm, the Windows setup.exe and
the Android APK are not listed there and have no published checksum.
The WayMore CLI is the same agent for the command line, installed with a single command.
Subscription plans cover WayMore Vibe, the WayMore CLI and the web app. Other coding agents pointed at the WayMore API — Claude Code, OpenCode, Cursor and similar — are billed as API usage rather than covered by a subscription. If you need to use one, contact us to enable API billing.
LLM Portal provides an OpenAI-compatible API. If you are migrating from OpenAI or Anthropic Claude, the transition requires minimal changes.
OpenAI clients
Swap base URL, API key, and model ID. No schema changes.
Anthropic clients
Point the Anthropic SDK at /v1/messages — Claude payloads including tool_use blocks are translated automatically.
The API is fully compatible with the OpenAI format. You only need to change three things:
| Setting | OpenAI | LLM Portal |
|---|---|---|
| Base URL | https://api.openai.com/v1 | https://chat.waymore.ai/v1 |
| API Key | sk-... | Generate from dashboard |
| Model | gpt-4o | Waymore-A1-Instruct-1011 |
Everything else — request/response format, streaming, function calling, message roles — works identically. You can use the OpenAI Python or Node.js SDK by simply overriding the base_url.
LLM Portal serves the Anthropic Messages API at /v1/messages. Your existing Claude request bodies — including the top-level system field, input_schema tool definitions, and tool_use/tool_result content blocks — are translated automatically, and responses (including streaming events) come back in Anthropic format. The Anthropic SDKs work by overriding the base URL, and x-api-key authentication is accepted. You only need to change:
| Setting | Anthropic | LLM Portal |
|---|---|---|
| Base URL | https://api.anthropic.com | https://chat.waymore.ai |
| Auth | x-api-key: sk-ant-... | x-api-key: YOUR_API_KEY |
| Endpoint | /v1/messages | /v1/messages (unchanged) |
| Model | claude-sonnet-4-5-* | Waymore-A1-Instruct-1011 |
See the Migrate from OpenAI and Migrate from Claude step-by-step guides for detailed examples and code samples.
LLM Portal supports multiple authentication methods depending on your use case.
API
Use Bearer tokens scoped per key, with optional IP rules.
Web access
Sessions rely on secure cookies, OAuth SSO, and optional TOTP.
For programmatic access, include your API key in the Authorization header as a Bearer token. API keys can be scoped with specific permissions and rate limits.
| 1 | Authorization: Bearer YOUR_API_KEY |
API keys work on the programmatic API surface — chat completions (/v1/chat/completions), model listing (/v1/models), and file upload/download. Account-management endpoints (API keys, billing, usage, content, 2FA) require a signed-in browser session and are not accessible with API keys.
Browser-based access uses secure HTTP-only cookies managed by NextAuth. Sessions are created automatically when you sign in through the web interface. Session tokens are JWT-based and refresh automatically.
Sign in with your existing Google or GitHub account. OAuth accounts are automatically linked if the email address matches an existing account.
Enhance your account security by enabling TOTP-based two-factor authentication. Once enabled, you will need to provide a 6-digit code from your authenticator app (e.g., Google Authenticator, Authy) each time you sign in. Backup codes are provided during setup for account recovery.
Enable 2FA from Settings → Security in the dashboard: generate the TOTP secret, scan the QR code with your authenticator app, then confirm with a 6-digit code. 2FA setup is only available while signed in to the web interface — it cannot be configured with an API key.
Passwords must be at least 12 characters and include uppercase letters, lowercase letters, numbers, and special characters. Password changes require your current password for verification.
The web-based chat interface provides a rich conversational experience with real-time streaming, code highlighting, file attachments, and more.
Best for
Teams that need live previews, streaming tokens, and quick file drops.
Highlights
Auto-titling, ratings, voice input, and syntax-highlighted responses.
Messages are organized into sessions (conversations). Each session maintains its own context and message history. You can create new sessions, rename them, and switch between them from the sidebar. Sessions are automatically titled based on the first message.
Responses stream in real-time using Server-Sent Events (SSE). You see each token as it is generated, providing immediate feedback. Streaming can be used both in the web interface and via the API by setting stream: true.
Code blocks in AI responses are automatically syntax-highlighted with a VS Code-inspired theme. Supported languages include JavaScript, TypeScript, Python, Java, Go, Rust, SQL, HTML, CSS, and many more. Each code block includes a copy button and line numbers.
Attach files to your messages for the AI to analyze. Supported file types include images (PNG, JPG, GIF, WebP), PDFs, documents, spreadsheets, and code files. Each file can be up to 50MB, with a maximum of 5 files per message.
Rate AI responses with thumbs up or thumbs down to help improve response quality. Ratings are tracked and can be used for analytics.
Use the microphone button to dictate messages using speech-to-text. Voice input uses a WebSocket connection for real-time transcription.
API keys provide programmatic access to the LLM Portal API. Each key can be configured with specific permissions, rate limits, and IP restrictions.
Rotation
Instantly revoke or regenerate keys without redeploying clients.
Controls
Fine-grained scopes, RPM caps, IP whitelists, and expirations.
Create API keys from the web dashboard while signed in (key management endpoints use your browser session — an API key cannot create other keys). The number of keys you can create depends on your subscription plan: 2 for Free, 5 for Starter, 20 for Pro, 100 for Enterprise. The full key value is shown only once at creation — store it securely.
| 1 | { |
| 2 | "name": "Production Key", |
| 3 | "description": "Backend integration key", |
| 4 | "permissions": ["chat", "images", "vision", "research"], |
| 5 | "ipWhitelist": ["203.0.113.0/24"], |
| 6 | "dailyLimit": 10000, |
| 7 | "monthlyLimit": 250000, |
| 8 | "rpmLimit": 60, |
| 9 | "expiresInDays": 90 |
| 10 | } |
API keys support granular permissions to restrict what operations the key can perform:
| Permission | Description |
|---|---|
| chat | Send chat completion requests |
| images | Generate and process images |
| vision | Analyze images and visual content |
| research | Run research and web-search tools |
Each key can have configurable rate limits: requests per minute (RPM), daily token limit, and monthly token limit. When a limit is exceeded, the API returns a 429 Too Many Requests response.
Restrict API key usage to specific IP addresses or CIDR ranges. Requests from non-whitelisted IPs will be rejected with a 403 Forbidden response.
API keys can be in one of three states: Active, Revoked, or Expired. You can regenerate a key to get a new secret while keeping the same configuration. Revoked keys can be reactivated if needed. Keys can also be set to auto-expire after a specified number of days.
LLM Portal provides access to AI models for text generation, analysis, and conversation.
Query the models endpoint to see every model available to your account and plan. It accepts an API key or a signed-in browser session.
| 1 | curl https://chat.waymore.ai/v1/models \ |
| 2 | -H "Authorization: Bearer sk-YOUR_API_KEY" |
| 1 | { |
| 2 | "object": "list", |
| 3 | "data": [ |
| 4 | { "id": "Valkyrie 5", "owned_by": "waymore" }, |
| 5 | { "id": "Waymore-A1-Instruct-1011", "owned_by": "waymore" } |
| 6 | ] |
| 7 | } |
| Model ID | Context | Max output | Availability |
|---|---|---|---|
| Astrape | 1M | 128K | All plans |
| Muse | 1M | 64K | All plans |
| Valkyrie 5 | 1M | 128K | All plans |
| Waymore-A1-Instruct-1011 | 1M | 128K | All plans |
| Waymore-A1-Instruct-1012 | 1M | 128K | All plans |
| Waymore-A1-Turbo | 1M | 64K | All plans |
| Atlas 5 (Restricted) | 2M | 768K | Opt-in only |
Astrape — WayMore Astrape — fast 1M-context model with always-on reasoning. Open to all plans.Muse — WayMore Muse — fast 1M-context multimodal model. Open to all plans.Valkyrie 5 — WayMore Valkyrie 5 — flagship 1M-context model with always-on reasoning. Open to all plans.Waymore-A1-Instruct-1011 — WayMore A1 Instruct — 1M context, 128K max output.Waymore-A1-Instruct-1012 — WayMore A1 Instruct 1012 — 1M context, 128K max output.Waymore-A1-Turbo — WayMore A1 Turbo — fast chat, non-thinking by default; honors an explicit thinking flag. 1M context.Atlas 5 (Restricted) — WayMore Atlas 5 (Restricted) — most-capable premium model: 2M context with extra-high reasoning for complex, multi-step agentic tasks. Opt-in only — apply for access. (access is opt-in — contact support to be enabled)Pass any non-restricted model ID as the model field on a
chat completion request. If you have no preference, Waymore-A1-Instruct-1011 is
the general-purpose default, and WayMore auto-routes each request to the best backend for the prompt.
To test whether a key still works, make a real request and read the status code:
200 means the key is valid,
401 means it is wrong, revoked or expired,
403 means it is valid but not permitted for that model, and
429 means it is valid but rate-limited.
Keys issued in the dashboard begin with sk-.
Do not test a key against /api/chat/models. That endpoint
is internal to the web interface and authenticates with a browser session only, so it returns
401 for every API key — valid or not.
When sending a chat completion request, you can configure the following parameters:
| Parameter | Type | Description |
|---|---|---|
| model | string | Model ID to use for completion |
| messages | array | Array of message objects with role and content |
| stream | boolean | Enable SSE streaming (default: false) |
| temperature | number | Sampling temperature (0-2, default: 0.7) |
| session_id | string | Optional session to associate the completion with |
Extend the model's capabilities by defining custom functions (tools) that it can invoke during a conversation. The API supports both OpenAI and Anthropic tool formats — use the OpenAI format on /v1/chat/completions and the Anthropic format on /v1/messages.
You define tools in your API request. When the model determines a tool should be used, it returns the function name and structured arguments. You execute the function on your side, then send the result back in a follow-up request. The model then generates a final response using the tool output.
Each endpoint responds in its own format:
| Feature | OpenAI Format | Anthropic Format |
|---|---|---|
| Tool definition | {type: "function", function: {parameters: ...}} | {name: ..., input_schema: ...} |
| Tool call response | tool_calls array | tool_use content block |
| Tool result | role: "tool" message | tool_result content block |
| Stop reason | finish_reason: "tool_calls" | stop_reason: "tool_use" |
Each tool has a type of "function" and a function object containing the name, description, and JSON Schema parameters:
| 1 | { |
| 2 | "tools": [ |
| 3 | { |
| 4 | "type": "function", |
| 5 | "function": { |
| 6 | "name": "get_weather", |
| 7 | "description": "Get the current weather for a given location", |
| 8 | "parameters": { |
| 9 | "type": "object", |
| 10 | "properties": { |
| 11 | "location": { |
| 12 | "type": "string", |
| 13 | "description": "City and country, e.g. Athens, Greece" |
| 14 | } |
| 15 | }, |
| 16 | "required": ["location"] |
| 17 | } |
| 18 | } |
| 19 | } |
| 20 | ], |
| 21 | "tool_choice": "auto" |
| 22 | } |
| Option | Behavior |
|---|---|
| "auto" | Model decides whether to call a tool (default) |
| "none" | Model will not call any tools |
| "required" | Model must call at least one tool |
The model can call multiple tools in a single response. For example, asking "What's the weather in Athens and London?" may produce two tool calls in the same response. Each has a unique ID — submit results for all of them before making the next completion request.
The complete function calling flow involves three steps:
tools defined. The model returns tool calls with function names and arguments.tool role messages in OpenAI format, or tool_result content blocks in Anthropic format). The model generates a natural language response.See the API Reference for complete request/response examples, and the Function Calling Guide for a step-by-step tutorial.
Monitor your API consumption, track costs, and analyze usage patterns through the usage dashboard or API endpoints.
The web dashboard provides visual charts showing your request volume, token consumption, cost breakdown, and error rates over time. Filter by date range, API key, model, and request status.
Use the usage API to programmatically retrieve your consumption data. Supports filtering by time period, API key, and model.
| 1 | # Get usage summary for the last 30 days |
| 2 | curl "https://chat.waymore.ai/api/usage/summary?period=30d" \ |
| 3 | -H "Authorization: Bearer YOUR_API_KEY" |
| 4 | |
| 5 | # Filter by model |
| 6 | curl "https://chat.waymore.ai/api/usage/summary?period=7d&model=Waymore-A1-Instruct-1011" \ |
| 7 | -H "Authorization: Bearer YOUR_API_KEY" |
| Metric | Description |
|---|---|
| Total Requests | Number of API calls made |
| Input Tokens | Tokens sent in prompts |
| Output Tokens | Tokens generated by the model |
| Cost | Estimated spend for the selected period |
| Latency | P50/P95 response times |
Set up usage alerts to receive email notifications when you approach or exceed token or cost thresholds.
View usage statistics for individual API keys, including daily breakdowns and request history:
| 1 | curl "https://chat.waymore.ai/api/keys/YOUR_KEY_ID/usage?days=30" \ |
| 2 | -H "Authorization: Bearer YOUR_API_KEY" |
Every plan covers the WayMore CLI, WayMore Vibe and the web app. Pick a tier by how many requests you make and how many machines you work on.
Prices are per month. Devices is how many machines can be signed in at once (see WayMore CLI for how devices are paired and counted).
| Plan | Price | Devices | Requests / day | / week | / month | Requests / min |
|---|---|---|---|---|---|---|
| Free | $0 | 3 | 25 | 40 | 50 | — |
| Lite | $6 | 3 | 113 | 150 | 150 | 20 |
| Standard | $16 | 5 | 300 | 400 | 400 | 30 |
| Pro | $50 | 10 | 938 | 1,250 | 1,250 | 60 |
| Max | $100 | 10 | 1,875 | 2,500 | 2,500 | 90 |
| Ultimate | $199 | 20 | 3,750 | 5,000 | 5,000 | 150 |
Team plans are billed per seat. One organization holds one subscription and one payment method, and each member gets the allowances below individually — they are not a shared pool. See Teams for setting one up.
| Plan | Price / seat | Devices / member | Requests / day | / week | / month | Requests / min |
|---|---|---|---|---|---|---|
| Team Starter | $45 | 10 | 938 | 1,250 | 1,250 | 60 |
| Team Business | $90 | 20 | 1,875 | 2,500 | 2,500 | 90 |
| Team Enterprise | $180 | 50 | 3,750 | 5,000 | 5,000 | 150 |
The daily, weekly and monthly figures are three separate rolling windows, all enforced at once. A Pro plan allows 938 requests in a day, but not seven days of that in a row — the weekly ceiling of 1,250 applies first. The per-minute figure is a burst limit on top.
Going over any window returns 429. See Errors & limits for what to
do about it.
Paid plans are activated through checkout in the billing dashboard, where you enter card details and the subscription is created before the plan is applied to your account.
Changing plans from the API is deliberately limited: you can always move down a tier or between free plans, but a self-service upgrade to a paid plan is refused. Upgrades go through checkout, or through sales if you pay by bank transfer.
Payments are processed by Braintree. Card details are entered into Braintree's own hosted form and never reach WayMore's servers — we store only the resulting token. You can keep more than one instrument on file and set a default for recurring charges.
Invoices for past payments are listed in the billing dashboard, itemised by plan charge, seat count where it applies, and any prorated adjustment from a plan change. Billing pages use your signed-in browser session; there is no API-key access to billing data.
Cancel at any time from the billing dashboard. Cancellation takes effect at the end of the current billing period and you keep your plan's features until then. Cancelling a team subscription ends it for every seat in the organization.
An organization puts a group of people on one subscription and one invoice, while each member keeps their own devices and their own request allowance.
An organization holds one subscription — a Team plan from Billing & Plans — and pays as one customer. Every member is a seat, and the price is per seat.
Allowances are per member, not pooled. On Team Business each member gets 2,500 requests a month and up to 20 devices of their own; one heavy user cannot consume a quieter colleague's allowance.
From the billing dashboard, give the organization a name, a short URL slug and a billing email. You become its owner. A new organization has no subscription yet — subscribe to a Team plan to start adding members.
One person can own at most 5 organizations. Being a member of others does not count towards that.
| Role | Can do |
|---|---|
| Owner | Everything, including billing, seat count, and transferring ownership |
| Admin | Invite and remove members, change member roles |
| Member | Use the plan |
There is exactly one owner at a time. To hand an organization over, transfer ownership — an owner cannot simply be removed, and an account that still owns an organization cannot be deleted.
Invite people by email address. They receive a link and, after signing in, join with the role you picked. Invite links expire after 7 days by default (30 at the most), and you can revoke one before it is used.
An invite is refused when:
That last one is the common case. Raise the seat count first, then re-send.
The seat count is what you are billed for, and it caps membership: adding a member when every seat is taken is refused. Seats can be increased at any time. They cannot be reduced below the number of members you currently have — remove members first.
If you belong to several organizations that each pay for a Team plan, the billing page shows which one you are currently using and lets you switch. Your CLI requests are then billed and metered against that organization.
If you have a personal plan as well, you can switch back to it the same way. Members of a single organization see no picker — there is nothing to choose between.
Only the owner can see invoices and change the plan. Members see which organization they belong to, and the owner's email address for billing questions.
Save and organize content from your AI conversations into a personal library. Content items include images, videos, files, code snippets, conversations, and notes.
| Type | Description |
|---|---|
| IMAGE | Generated or uploaded images |
| VIDEO | Video files and recordings |
| FILE | Documents, PDFs, spreadsheets |
| CODE | Code snippets with syntax highlighting |
| CONVERSATION | Saved chat conversations |
| NOTE | Text notes and annotations |
Use tags, favorites, and collections to keep your library organized. Content items support full-text search across titles, descriptions, and tags. Filter by type, source, favorite status, and archive status.
| 1 | # Search for favorite images |
| 2 | curl "https://chat.waymore.ai/api/stuff?type=IMAGE&favorite=true&search=landscape" \ |
| 3 | -H "Authorization: Bearer YOUR_API_KEY" |
| 4 | |
| 5 | # Get content statistics |
| 6 | curl "https://chat.waymore.ai/api/stuff/stats" \ |
| 7 | -H "Authorization: Bearer YOUR_API_KEY" |
Each account has a storage limit based on your subscription plan. Track your storage usage through the content statistics endpoint. File uploads are limited to 50MB per file.
Group related content items into collections for better organization. Each collection can have a custom name, description, color, and icon.
Create collections from the content library page. A default collection is created automatically for each new account. Collection endpoints authenticate with your signed-in browser session — they are not accessible with API keys.
| 1 | { |
| 2 | "name": "Research Papers", |
| 3 | "description": "Academic papers and references", |
| 4 | "color": "#3B82F6", |
| 5 | "icon": "book" |
| 6 | } |
Add or remove content items from collections in the content library. An item can belong to multiple collections. Default collections cannot be deleted.
| 1 | # Add an item to a collection |
| 2 | POST /api/collections/COLLECTION_ID/items |
| 3 | {"itemId": "ITEM_ID"} |
| 4 | |
| 5 | # Remove an item from a collection |
| 6 | DELETE /api/collections/COLLECTION_ID/items?itemId=ITEM_ID |
Canvas is a collaborative document editor linked to chat sessions. Use it to draft, edit, and iterate on content alongside your AI conversations.
Each chat session can have an associated canvas document. The canvas stores content alongside the conversation, allowing you to work on a document while discussing it with the AI. Canvas documents support version history with up to 50 snapshots.
Multiple collaborators can edit the same canvas in real time. Presence indicators show who is currently editing, along with their cursor position. Changes are synced instantly through our WebSocket infrastructure.
Canvas automatically tracks changes through version snapshots. You can view, compare, and restore previous versions. When the maximum of 50 versions is reached, the oldest versions are automatically removed.
Canvas endpoints authenticate with your signed-in browser session — they are not accessible with API keys.
| 1 | # Get canvas document for a session |
| 2 | GET /api/canvas/SESSION_ID |
| 3 | |
| 4 | # Create or update canvas document |
| 5 | PUT /api/canvas/SESSION_ID |
| 6 | {"title": "Draft Report", "content": "# Report\n\nContent here..."} |
| 7 | |
| 8 | # Create a version snapshot |
| 9 | POST /api/canvas/SESSION_ID/versions |
Upload files for AI processing or attach them to chat messages. The platform supports a wide range of file types.
| Category | Formats |
|---|---|
| Images | PNG, JPG, JPEG, GIF, WebP, SVG |
| Documents | PDF, DOC, DOCX, TXT, RTF |
| Data | CSV, JSON, XML, XLSX |
| Code | JS, TS, PY, JAVA, GO, RS, and more |
| Video | MP4, WebM, MOV |
Maximum file size is 50MB per file. Chat attachments are limited to 5 files per message. Files are processed through the LLM backend for AI analysis.
| 1 | # Upload a file (API key or session) |
| 2 | curl -X POST "https://chat.waymore.ai/api/files/upload" \ |
| 3 | -H "Authorization: Bearer YOUR_API_KEY" \ |
| 4 | -F "file=@document.pdf" |
Uploading directly to the content library (POST /api/stuff/upload) is a dashboard feature — it authenticates with your signed-in browser session and is not accessible with API keys.
LLM Portal is built with security as a priority. Here is an overview of the security measures in place.
All traffic is encrypted with TLS (HTTPS). HTTP Strict Transport Security (HSTS) is enforced with a max-age of 2 years, includeSubDomains, and preload. API keys and session tokens are only transmitted over encrypted connections.
The platform sets comprehensive security headers on all responses:
| Header | Value |
|---|---|
| X-Content-Type-Options | nosniff |
| X-Frame-Options | DENY |
| X-XSS-Protection | 1; mode=block |
| Referrer-Policy | strict-origin-when-cross-origin |
| Permissions-Policy | camera=(self), microphone=(self), geolocation=() |
Protect your account with strong passwords (minimum 12 characters), two-factor authentication, and API key IP whitelisting. Session tokens use secure, HTTP-only cookies that are not accessible to JavaScript.
Authentication endpoints are rate-limited to prevent brute-force attacks. API keys support configurable per-minute, daily, and monthly rate limits. Excessive requests return a 429 status code with a Retry-After header.
Every failure comes back as JSON with an error field. The status code tells
you whether to retry, fix the request, or change something on your account.
| Status | Meaning | What to do |
|---|---|---|
400 | The request body was malformed or a required field was missing | Fix the request; retrying will not help |
401 | No credentials, or a key that is wrong, revoked or expired | Check the key, or sign in again with waymore login |
403 | Authenticated, but not allowed — a blocked device, the device limit, or a model your plan does not include | See below; retrying will not help |
412 | The CLI has an unread notice that must be acknowledged | Acknowledge it in the CLI, then repeat the request |
429 | A rate or usage limit was hit | Back off and retry — see below |
5xx | A fault on our side | Retry with backoff; if it persists, contact support |
Two different 403s come from device control, and they are not interchangeable:
device_limit_reached — you are signed in on as many machines as your
plan allows. Revoke a key you no longer use, or move up a tier.device_blocked — an administrator blocked this specific device. Signing
in again will not clear it; the block survives re-pairing by design. The
response carries a block_id you can quote to your administrator.Device counts per plan are in Billing & Plans.
Your plan sets four limits at once: requests per minute, per day, per week and
per month. They are independent, and the tightest one wins — a 429 in the
middle of a quiet afternoon usually means the weekly or monthly window is full,
not the per-minute one.
Retry with exponential backoff rather than a fixed delay: wait a second, then two, then four, up to about a minute, and add a little random jitter so a fleet of workers does not retry in lockstep.
| 1 | delay=1 |
| 2 | until curl -sf -X POST https://chat.waymore.ai/v1/chat/completions \ |
| 3 | -H "Authorization: Bearer $WAYMORE_API_KEY" \ |
| 4 | -H "Content-Type: application/json" \ |
| 5 | -d @body.json -o response.json |
| 6 | do |
| 7 | sleep $(( delay + RANDOM % 2 )) |
| 8 | delay=$(( delay * 2 )) |
| 9 | [ "$delay" -gt 60 ] && break |
| 10 | done |
If a per-minute burst is the problem, backoff clears it in seconds. If the monthly window is exhausted, no amount of retrying will help before it rolls over — upgrade, or wait.
Current consumption for each window is shown under Usage.
Make a real request and read the status: 200 means the key works, 401 means
it is wrong or revoked, 403 means it is valid but not permitted for what you
asked, and 429 means it is valid and merely throttled.
Do not test a key against /api/chat/models. That endpoint belongs to the web
interface and accepts only a browser session, so it answers 401 for every API
key — working or not.