Waymore Docs

Documentation

Everything you need to integrate and use the LLM Portal platform.

LLM Portal APIv1.0

Launch production-ready AI experiences

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

Getting Started

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

Create an account

Sign up at https://chat.waymore.ai/register or use Google/GitHub SSO, then verify your email.

Step 2

Start chatting

You're dropped into the chat UI with streaming answers, conversation history, and ratings out of the box.

Step 3

Generate an API key

Visit the API Keys page, issue a scoped key, and copy it immediately — it is only shown once.

Step 4

Ship your first request

Use the OpenAI-compatible endpoint and the language tabs below to test.

cURL
1curl 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}'
Response
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}

WayMore CLI

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.

Installation

Install with a single command. The installer downloads the latest binary and configures your shell automatically.

macOS / Linux
1curl -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.

Verify Installation

Open a new terminal window after installing, then run:

Verify
1waymore --version

Signing in

Run waymore login. The CLI prints a short code and a URL, and waits.

Sign in
1waymore 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.

Devices

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.

Direct downloads

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:

OSDownload
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.

Verifying a download

The release manifest names the current version and, for each platform, the exact URL, SHA256 and byte size of that release:

Verify a downloaded binary
1curl -s https://cdn13.waymore.io/cdn/waymore/manifest.json | jq '.platforms["linux-x86_64"]'
2shasum -a 256 waymore-x86_64-latest

Platform keys are linux-x86_64, linux-aarch64, darwin-aarch64, darwin-x86_64 and windows-x86_64.

Pinning a version

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:

Version-pinned downloads
1https://cdn13.waymore.io/cdn/waymore/linux/waymore-x86_64-1.44.37
2https://cdn13.waymore.io/cdn/waymore/linux/waymore-aarch64-1.44.37
3https://cdn13.waymore.io/cdn/waymore/macos/waymore-aarch64-1.44.37
4https://cdn13.waymore.io/cdn/waymore/macos/waymore-x86_64-1.44.37
5https://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.

Updating

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.

Quick Start

With the CLI installed and signed in, run it inside a project directory:

Quick start
1cd ~/code/my-project
2waymore
3 
4# Every command and flag
5waymore --help

WayMore Vibe

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.

Download

All links are stable "always-latest" URLs — they always serve the current release, so you can bookmark them or reuse them in provisioning scripts.

Windows

FormatDownload
MSI installerWayMore-Vibe-latest-x86_64.msi
Setup executableWayMore-Vibe-latest-x86_64-setup.exe

macOS

FormatDownload
Apple Silicon (M1 and later)WayMore-Vibe-latest-aarch64.dmg
IntelWayMore-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.

Linux

FormatDownload
AppImage — x86_64 (any distribution)WayMore-Vibe-latest-x86_64.AppImage
AppImage — arm64 (any distribution)WayMore-Vibe-latest-aarch64.AppImage
Debian / Ubuntu — x86_64WayMore-Vibe-latest-x86_64.deb
Debian / Ubuntu — arm64WayMore-Vibe-latest-aarch64.deb
Fedora / RHEL — x86_64WayMore-Vibe-latest-x86_64.rpm
Fedora / RHEL — arm64WayMore-Vibe-latest-aarch64.rpm

Not sure which you need? Run uname -mx86_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

Linux system requirements

Vibe needs glibc 2.34 or newer, the same on both architectures, plus GTK 3 and WebKit2GTK 4.1. Check yours with ldd --version.

DistributionWorks
Ubuntu22.04 LTS and newer
Debian12 (bookworm) and newer
Fedora35 and newer
RHEL, Rocky, AlmaLinux9 and newer
openSUSETumbleweed, or Leap 16 and newer
Arch, and other rolling releasesyes

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.

Android

FormatDownload
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.

Android system requirements

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.

Staying up to date

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.

Pinning a specific version

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.

Verifying a download

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.

Prefer the terminal?

The WayMore CLI is the same agent for the command line, installed with a single command.

Third-party clients

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.

Migration

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.

From OpenAI

The API is fully compatible with the OpenAI format. You only need to change three things:

SettingOpenAILLM Portal
Base URLhttps://api.openai.com/v1https://chat.waymore.ai/v1
API Keysk-...Generate from dashboard
Modelgpt-4oWaymore-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.

From Claude (Anthropic)

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:

SettingAnthropicLLM Portal
Base URLhttps://api.anthropic.comhttps://chat.waymore.ai
Authx-api-key: sk-ant-...x-api-key: YOUR_API_KEY
Endpoint/v1/messages/v1/messages (unchanged)
Modelclaude-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.

Authentication

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.

API Key Authentication

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.

Authorization Header
1Authorization: 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.

Session Authentication

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.

OAuth Providers

Sign in with your existing Google or GitHub account. OAuth accounts are automatically linked if the email address matches an existing account.

Two-Factor Authentication (2FA)

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.

Password Requirements

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.

Chat Interface

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.

Conversations

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.

Streaming Responses

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 Highlighting

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.

File Attachments

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.

Message Ratings

Rate AI responses with thumbs up or thumbs down to help improve response quality. Ratings are tracked and can be used for analytics.

Voice Input

Use the microphone button to dictate messages using speech-to-text. Voice input uses a WebSocket connection for real-time transcription.

API Keys

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.

Creating Keys

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.

POST /api/keys (session-authenticated)
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}

Permissions

API keys support granular permissions to restrict what operations the key can perform:

PermissionDescription
chatSend chat completion requests
imagesGenerate and process images
visionAnalyze images and visual content
researchRun research and web-search tools

Rate Limits

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.

IP Whitelisting

Restrict API key usage to specific IP addresses or CIDR ranges. Requests from non-whitelisted IPs will be rejected with a 403 Forbidden response.

Key Lifecycle

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.

Models

LLM Portal provides access to AI models for text generation, analysis, and conversation.

Available Models

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.

cURL
1curl https://chat.waymore.ai/v1/models \
2-H "Authorization: Bearer sk-YOUR_API_KEY"
Response
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 IDContextMax outputAvailability
Astrape1M128KAll plans
Muse1M64KAll plans
Valkyrie 51M128KAll plans
Waymore-A1-Instruct-10111M128KAll plans
Waymore-A1-Instruct-10121M128KAll plans
Waymore-A1-Turbo1M64KAll plans
Atlas 5 (Restricted)2M768KOpt-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.

Checking an API key

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.

Model Parameters

When sending a chat completion request, you can configure the following parameters:

ParameterTypeDescription
modelstringModel ID to use for completion
messagesarrayArray of message objects with role and content
streambooleanEnable SSE streaming (default: false)
temperaturenumberSampling temperature (0-2, default: 0.7)
session_idstringOptional session to associate the completion with

Function Calling

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.

How It Works

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.

Supported Formats

Each endpoint responds in its own format:

FeatureOpenAI FormatAnthropic Format
Tool definition{type: "function", function: {parameters: ...}}{name: ..., input_schema: ...}
Tool call responsetool_calls arraytool_use content block
Tool resultrole: "tool" messagetool_result content block
Stop reasonfinish_reason: "tool_calls"stop_reason: "tool_use"

Tool Definitions

Each tool has a type of "function" and a function object containing the name, description, and JSON Schema parameters:

OpenAI Tool Format
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}

Controlling Tool Use

OptionBehavior
"auto"Model decides whether to call a tool (default)
"none"Model will not call any tools
"required"Model must call at least one tool

Parallel Tool Calls

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.

Multi-Turn Flow

The complete function calling flow involves three steps:

  1. Send a request with tools defined. The model returns tool calls with function names and arguments.
  2. Execute the function(s) on your side using the arguments provided by the model.
  3. Send the results back (as 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.

Usage & Analytics

Monitor your API consumption, track costs, and analyze usage patterns through the usage dashboard or API endpoints.

Usage Dashboard

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.

Querying Usage via API

Use the usage API to programmatically retrieve your consumption data. Supports filtering by time period, API key, and model.

cURL
1# Get usage summary for the last 30 days
2curl "https://chat.waymore.ai/api/usage/summary?period=30d" \
3-H "Authorization: Bearer YOUR_API_KEY"
4 
5# Filter by model
6curl "https://chat.waymore.ai/api/usage/summary?period=7d&model=Waymore-A1-Instruct-1011" \
7-H "Authorization: Bearer YOUR_API_KEY"

Metrics Tracked

MetricDescription
Total RequestsNumber of API calls made
Input TokensTokens sent in prompts
Output TokensTokens generated by the model
CostEstimated spend for the selected period
LatencyP50/P95 response times

Alerts

Set up usage alerts to receive email notifications when you approach or exceed token or cost thresholds.

Per-Key Usage

View usage statistics for individual API keys, including daily breakdowns and request history:

cURL
1curl "https://chat.waymore.ai/api/keys/YOUR_KEY_ID/usage?days=30" \
2-H "Authorization: Bearer YOUR_API_KEY"

Billing & Plans

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.

Individual plans

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).

PlanPriceDevicesRequests / day/ week/ monthRequests / min
Free$03254050
Lite$6311315015020
Standard$16530040040030
Pro$50109381,2501,25060
Max$100101,8752,5002,50090
Ultimate$199203,7505,0005,000150

Team plans

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.

PlanPrice / seatDevices / memberRequests / day/ week/ monthRequests / min
Team Starter$45109381,2501,25060
Team Business$90201,8752,5002,50090
Team Enterprise$180503,7505,0005,000150

How the request limits work

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.

Starting a paid plan

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.

Payment methods

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

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.

Cancellation

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.

Teams

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.

How a team plan works

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.

Creating an organization

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.

Roles

RoleCan do
OwnerEverything, including billing, seat count, and transferring ownership
AdminInvite and remove members, change member roles
MemberUse 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.

Inviting members

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:

  • the link has already been used, or was revoked
  • it has expired
  • the signed-in email does not match the address the invite was sent to
  • the organization has no free seat

That last one is the common case. Raise the seat count first, then re-send.

Seats

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.

Working in more than one organization

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.

Who to ask about billing

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.

Content Library

Save and organize content from your AI conversations into a personal library. Content items include images, videos, files, code snippets, conversations, and notes.

Content Types

TypeDescription
IMAGEGenerated or uploaded images
VIDEOVideo files and recordings
FILEDocuments, PDFs, spreadsheets
CODECode snippets with syntax highlighting
CONVERSATIONSaved chat conversations
NOTEText notes and annotations

Organizing Content

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.

cURL
1# Search for favorite images
2curl "https://chat.waymore.ai/api/stuff?type=IMAGE&favorite=true&search=landscape" \
3-H "Authorization: Bearer YOUR_API_KEY"
4 
5# Get content statistics
6curl "https://chat.waymore.ai/api/stuff/stats" \
7-H "Authorization: Bearer YOUR_API_KEY"

Storage

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.

Collections

Group related content items into collections for better organization. Each collection can have a custom name, description, color, and icon.

Creating Collections

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.

POST /api/collections (session-authenticated)
1{
2"name": "Research Papers",
3"description": "Academic papers and references",
4"color": "#3B82F6",
5"icon": "book"
6}

Managing Items

Add or remove content items from collections in the content library. An item can belong to multiple collections. Default collections cannot be deleted.

Endpoints (session-authenticated)
1# Add an item to a collection
2POST /api/collections/COLLECTION_ID/items
3{"itemId": "ITEM_ID"}
4 
5# Remove an item from a collection
6DELETE /api/collections/COLLECTION_ID/items?itemId=ITEM_ID

Canvas Documents

Canvas is a collaborative document editor linked to chat sessions. Use it to draft, edit, and iterate on content alongside your AI conversations.

How Canvas Works

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.

Live Collaboration

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.

Version History

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.

Endpoints (session-authenticated)
1# Get canvas document for a session
2GET /api/canvas/SESSION_ID
3 
4# Create or update canvas document
5PUT /api/canvas/SESSION_ID
6{"title": "Draft Report", "content": "# Report\n\nContent here..."}
7 
8# Create a version snapshot
9POST /api/canvas/SESSION_ID/versions

Files & Uploads

Upload files for AI processing or attach them to chat messages. The platform supports a wide range of file types.

Supported File Types

CategoryFormats
ImagesPNG, JPG, JPEG, GIF, WebP, SVG
DocumentsPDF, DOC, DOCX, TXT, RTF
DataCSV, JSON, XML, XLSX
CodeJS, TS, PY, JAVA, GO, RS, and more
VideoMP4, WebM, MOV

Upload Limits

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.

cURL
1# Upload a file (API key or session)
2curl -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.

Security

LLM Portal is built with security as a priority. Here is an overview of the security measures in place.

Transport Security

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.

Security Headers

The platform sets comprehensive security headers on all responses:

HeaderValue
X-Content-Type-Optionsnosniff
X-Frame-OptionsDENY
X-XSS-Protection1; mode=block
Referrer-Policystrict-origin-when-cross-origin
Permissions-Policycamera=(self), microphone=(self), geolocation=()

Account Security

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.

Rate Limiting

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.

Errors & limits

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 codes

StatusMeaningWhat to do
400The request body was malformed or a required field was missingFix the request; retrying will not help
401No credentials, or a key that is wrong, revoked or expiredCheck the key, or sign in again with waymore login
403Authenticated, but not allowed — a blocked device, the device limit, or a model your plan does not includeSee below; retrying will not help
412The CLI has an unread notice that must be acknowledgedAcknowledge it in the CLI, then repeat the request
429A rate or usage limit was hitBack off and retry — see below
5xxA fault on our sideRetry with backoff; if it persists, contact support

403 in detail

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.

429 and the request windows

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.

Backoff sketch
1delay=1
2until 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
6do
7sleep $(( delay + RANDOM % 2 ))
8delay=$(( delay * 2 ))
9[ "$delay" -gt 60 ] && break
10done

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.

Checking whether a key is the problem

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.

Updated September 2026