Guides

Go to https://chat.waymore.ai/register and create your account using email, Google, or GitHub.

Check your inbox for a verification email and click the link to activate your account. If you signed up with Google or GitHub, this step is automatic.

After signing in, you will see the chat interface. Type a message in the input box and press Enter. The AI will respond in real-time with streaming text.

Try attaching a file to your message, creating a new chat session from the sidebar, or enabling two-factor authentication in your profile settings.

Navigate to your API Keys page in the dashboard. Click "Create New Key", give it a descriptive name, and select the permissions it needs. Keys are created and managed in the dashboard with your signed-in session — the key-management endpoints are not accessible with API keys.

Important: Copy the API key immediately. It will only be shown once.

Use cURL or any HTTP client to send a chat completion request:

The response follows the OpenAI-compatible format. The assistant's message is in choices[0].message.content:

The usage field in the response shows token consumption for each request. For an overall view, use the Usage page in the dashboard, or query GET /api/usage/summary with your API key as a Bearer token.

The following are fully compatible — no code changes needed for these:

• Request format: messages, model, stream, temperature
• Response format: choices, usage, finish_reason
• Streaming via Server-Sent Events (SSE)
• Function calling / Tools (tools, tool_choice, parallel tool calls)
• Message roles: system, user, assistant, tool
• Bearer token authentication

Replace the OpenAI base URL with the LLM Portal endpoint:

If you use the OpenAI Python or Node.js SDK, override the base_url and api_key:

Replace OpenAI model names (gpt-4o, gpt-4-turbo, gpt-3.5-turbo) with Waymore-A1-Instruct-1011. Use the GET /v1/models endpoint (or client.models.list() in the SDK) to list all available models.

The official Anthropic SDKs work out of the box — set the base URL to https://chat.waymore.ai (the SDK appends /v1/messages) and use your LLM Portal API key. The SDK's x-api-key header is accepted, as is Authorization: Bearer:

Raw HTTP requests only need a new URL, key, and model name. As with the Anthropic API, model, messages, and max_tokens are required:

/v1/messages accepts Anthropic-format requests and responds in the Anthropic format:

• Top-level system field for system prompts
• Content blocks ([{"type": "text", ...}]) as well as plain string content
• Tool definitions with input_schema; tool calls via tool_use and results via tool_result content blocks
• Anthropic response shape (content[], stop_reason, usage.input_tokens/output_tokens)
• Streaming with Anthropic SSE events (message_start, content_block_delta, message_delta, message_stop)

Authenticate with x-api-key or Authorization: Bearer. The anthropic-version header is not required.

If you would rather standardize on the OpenAI-compatible POST /v1/chat/completions endpoint instead, convert your requests: move the top-level system field into a {"role": "system"} message, wrap tools in {"type": "function", "function": {...}} (renaming input_schema to parameters), send tool results as {"role": "tool"} messages, and read choices[0].message.content / finish_reason instead of content[] / stop_reason. See the Migrate from OpenAI and Function Calling guides.

Set stream: true in your request body:

The response is a Server-Sent Events (SSE) stream. Each event contains a JSON chunk with the next token:

Each delta.content field contains a text fragment. Concatenate all fragments to build the complete response. The stream ends with data: [DONE].

Create a tool definition describing your function's name, purpose, and parameters using JSON Schema:

Tip: Write clear descriptions for both the function and each parameter. This helps the model decide when and how to use the tool.

Include the tools array and set tool_choice in your completion request:

When the model wants to use a tool, the response has finish_reason: "tool_calls" and includes a tool_calls array:

Parse the arguments field (it's a JSON string) and execute your function with those parameters.

Run your function using the arguments the model provided. In this example, you would call your weather API with location: "Athens, Greece" and get back the current conditions.

Send the function result back to the model in a follow-up request. Include the full conversation history plus a tool role message with the matching tool_call_id:

The model uses the tool result to generate a natural language answer:

Click "New Chat" in the sidebar to start a named session that groups related messages. Under the hood, the web app calls POST /api/chat/sessions with your browser session:

When you chat inside a session, the web app associates each completion request with the session via session_id on the web-app endpoint /api/chat/completions:

Open a session from the sidebar to review the full conversation history. The web app loads it via the session-cookie-authenticated endpoint:

Rename a session from its context menu in the sidebar, or delete it entirely — deleting a session removes all its messages. The corresponding endpoints (also browser-session authenticated):

Create separate API keys for development, staging, and production. This limits the blast radius if a key is compromised and makes it easy to revoke access for a single environment.

Only grant the permissions each key actually needs. A key used only for chat completions should not have image or vision permissions:

For production keys, restrict access to your server's IP addresses:

Configure rate limits to prevent runaway costs and set expiration dates for temporary access. Use rpmLimit for requests per minute, dailyLimit and monthlyLimit for token caps, and expiresInDays for auto-expiration.

Regenerate API key secrets periodically using the "Regenerate" action on the key's detail page in the dashboard. You get a new secret while keeping the same configuration. Key management endpoints (/api/keys/*) use your signed-in browser session and are not accessible with API keys.

Note: The old key secret is immediately invalidated. Update your applications before or immediately after regenerating.

Regularly review each key's usage to detect anomalies. Per-key usage is readable with an API key:

Request history (GET /api/keys/YOUR_KEY_ID/requests) is available on the key's detail page in the dashboard; that endpoint uses your signed-in browser session only.

Click the paperclip button in the chat input (or drag and drop) to attach a file. The web app uploads it via POST /api/chat/attachments (multipart form, browser session auth) and gets back a file URL to reference in the message.

The web app then creates the message with the attachment metadata included:

Each file can be up to 50MB. You can attach up to 5 files per message. Supported formats include images (PNG, JPG, GIF, WebP), documents (PDF, DOC, DOCX, TXT), data files (CSV, JSON, XML), and code files.

Save images, code snippets, notes, or any valuable content from your conversations. The web app stores each item via:

Group related items into a collection with a custom name and color:

Add content items to your new collection:

Use the search box and filters on the My Stuff page — or query your library programmatically. GET /api/stuff and GET /api/stuff/stats accept your API key as a Bearer token:

Query the usage summary endpoint for an overview of your consumption:

Narrow down usage data using query parameters on the summary endpoint:

The available filter options (models, keys, date presets) are listed in the dashboard's Usage page filter controls; the GET /api/usage/filters endpoint behind them uses your signed-in browser session only.

The usage summary includes a cost breakdown by token type (input vs output) and by model. Use this to understand where your budget is going and optimize your prompts for cost efficiency.

Monitor individual API keys to track which integrations consume the most tokens:

Per-key request history (GET /api/keys/KEY_ID/requests) is available on the key's detail page in the dashboard; that endpoint uses your signed-in browser session only.