Quickstart

Get started with Nordlys by changing one line of code. No complex setup required. Nordlys is a Mixture of Models model: each prompt activates the right models under the hood.

Step 1: Get Your API Key

Create a free account to get started

Generate Key

Generate your API key from the dashboard

Step 2: Install SDK (Optional)

pip install nordlys-py

uv add nordlys-py

poetry add nordlys-py

Python only - native Nordlys SDK with Registry and Router APIs

Python
Node.js

pip install openai

uv add openai

poetry add openai

npm install openai

pnpm add openai

yarn add openai

bun add openai

Python
Node.js

pip install anthropic

uv add anthropic

poetry add anthropic

npm install @anthropic-ai/sdk

pnpm add @anthropic-ai/sdk

yarn add @anthropic-ai/sdk

bun add @anthropic-ai/sdk

Python
Node.js

pip install google-generativeai

uv add google-generativeai

poetry add google-generativeai

npm install @google/genai

pnpm add @google/genai

yarn add @google/genai

bun add @google/genai

npm install ai @ai-sdk/openai

pnpm add ai @ai-sdk/openai

yarn add ai @ai-sdk/openai

bun add ai @ai-sdk/openai

Node.js only

Python
Node.js

pip install langchain-openai

uv add langchain-openai

poetry add langchain-openai

npm install @langchain/openai

pnpm add @langchain/openai

yarn add @langchain/openai

bun add @langchain/openai

Authentication

Nordlys uses API keys for authentication. Include your API key in requests:

Header: Authorization: Bearer YOUR_API_KEY
Store keys in environment variables (NORDLYS_API_KEY)

Step 3: Make Your First Request

Choose your preferred language and framework:

from nordlys_py import Nordlys

nordlys = Nordlys(api_key="your-nordlys-api-key")

response = nordlys.chat.completions.create(
    model="nordlys/hypernova",
    messages=[{"role": "user", "content": "Hello!"}]
)

print(response.choices[0].message.content)

import asyncio
from nordlys_py import AsyncNordlys

async def main():
    async with AsyncNordlys(api_key="your-nordlys-api-key") as nordlys:
        response = await nordlys.chat.completions.create(
            model="nordlys/hypernova",
            messages=[{"role": "user", "content": "Hello!"}]
        )
        print(response.choices[0].message.content)

asyncio.run(main())

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'your-nordlys-api-key',
  baseURL: 'https://api.nordlyslabs.com/v1'
});

const response = await client.chat.completions.create({
  model: 'nordlys/hypernova',
  messages: [{ role: 'user', content: 'Hello!' }]
});

console.log(response.choices[0].message.content);

from openai import OpenAI

client = OpenAI(
    api_key="your-nordlys-api-key",
    base_url="https://api.nordlyslabs.com/v1"
)

response = client.chat.completions.create(
    model="nordlys/hypernova",
    messages=[{"role": "user", "content": "Hello!"}]
)

print(response.choices[0].message.content)

curl https://api.nordlyslabs.com/v1/chat/completions \
  -H "Content-Type: application/json" \
   -H "Authorization: Bearer apk_123456" \
  -d '{
    "model": "nordlys/hypernova",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: 'your-nordlys-api-key',
  baseURL: 'https://api.nordlyslabs.com/v1'
});

const response = await client.messages.create({
  model: 'nordlys/hypernova',
  max_tokens: 1000,
  messages: [{ role: 'user', content: 'Hello!' }]
});

console.log(response.content[0].text);

import anthropic

client = anthropic.Anthropic(
    api_key="your-nordlys-api-key",
    base_url="https://api.nordlyslabs.com/v1"
)

response = client.messages.create(
    model="nordlys/hypernova",
    max_tokens=1000,
    messages=[{"role": "user", "content": "Hello!"}]
)

print(response.content[0].text)

curl https://api.nordlyslabs.com/v1/messages \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer apk_123456" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "nordlys/hypernova",
    "max_tokens": 1000,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

import { GoogleGenerativeAI } from '@google/genai';

const genAI = new GoogleGenerativeAI({
  apiKey: process.env.NORDLYS_API_KEY || 'your-nordlys-api-key',
  httpOptions: {
    baseUrl: 'https://api.nordlyslabs.com/v1beta'
  }
});

const model = genAI.getGenerativeModel({ model: 'nordlys/hypernova' });

const result = await model.generateContent({
  contents: [
    {
      role: 'user',
      parts: [{ text: 'Hello!' }]
    }
  ],
  generationConfig: {
    maxOutputTokens: 512
  }
});

console.log(result.response.text());

import os
import google.generativeai as genai

genai.configure(
    api_key=os.getenv("NORDLYS_API_KEY", "your-nordlys-api-key"),
    transport="rest",
    client_options={"api_endpoint": "https://api.nordlyslabs.com/v1beta"}
)

model = genai.GenerativeModel("nordlys/hypernova")

response = model.generate_content(
    "Hello!",
    generation_config={"max_output_tokens": 512}
)

print(response.text)

curl https://api.nordlyslabs.com/v1beta/models/nordlys/hypernova:generateContent \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer apk_123456" \
  -d '{
    "contents": [
      {
        "role": "user",
        "parts": [{"text": "Hello!"}]
      }
    ],
    "generationConfig": {
      "maxOutputTokens": 512
    }
  }'

import { openai } from '@ai-sdk/openai';
import { generateText } from 'ai';

const { text } = await generateText({
  model: openai('nordlys/hypernova', {
    baseURL: 'https://api.nordlyslabs.com/v1',
    apiKey: 'your-nordlys-api-key'
  }),
  prompt: 'Hello!'
});

console.log(text);

import { openai } from '@ai-sdk/openai';
import { streamText } from 'ai';

const { textStream } = await streamText({
  model: openai('nordlys/hypernova', {
    baseURL: 'https://api.nordlyslabs.com/v1',
    apiKey: 'your-nordlys-api-key'
  }),
  prompt: 'Write a story about AI'
});

for await (const delta of textStream) {
  process.stdout.write(delta);
}

import { useChat } from 'ai/react';

export default function Chat() {
  const { messages, input, handleInputChange, handleSubmit } = useChat({
    api: '/api/chat', // Your API route
    initialMessages: [{ role: 'system', content: 'Hello!' }]
  });

  return (
    <div>
      {messages.map(m => (
        <div key={m.id}>
          {m.role}: {m.content}
        </div>
      ))}
      <form onSubmit={handleSubmit}>
        <input value={input} onChange={handleInputChange} />
      </form>
    </div>
  );
}

import { ChatOpenAI } from '@langchain/openai';

const model = new ChatOpenAI({
  openAIApiKey: 'your-nordlys-api-key',
  configuration: {
    baseURL: 'https://api.nordlyslabs.com/v1'
  },
  modelName: 'nordlys/hypernova'
});

const response = await model.invoke('Hello!');
console.log(response.content);

from langchain_openai import ChatOpenAI

model = ChatOpenAI(
    openai_api_key="your-nordlys-api-key",
    openai_api_base="https://api.nordlyslabs.com/v1",
    model_name="nordlys/hypernova"
)

response = model.invoke("Hello!")
print(response.content)

from langchain_openai import ChatOpenAI
from langchain.chains import AI modelChain
from langchain.prompts import PromptTemplate

model = ChatOpenAI(
    openai_api_key="your-nordlys-api-key",
    openai_api_base="https://api.nordlyslabs.com/v1",
    model_name="nordlys/hypernova"
)

prompt = PromptTemplate(
    input_variables=["topic"],
    template="Write a brief summary about {topic}"
)

chain = AI modelChain(llm=model, prompt=prompt)
result = chain.run(topic="artificial intelligence")
print(result)

Error Handling

Always implement proper error handling in production. Nordlys provides detailed error information to help you build resilient applications.

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.NORDLYS_API_KEY,
  baseURL: 'https://api.nordlyslabs.com/v1'
});

async function chatWithRetry(message: string, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const response = await client.chat.completions.create({
        model: 'nordlys/hypernova',
        messages: [{ role: 'user', content: message }]
      });

      return response.choices[0].message.content;

    } catch (error: any) {
      console.error(`Attempt ${attempt} failed:`, error.message);

      if (attempt === maxRetries) throw error;

      // Exponential backoff
      await new Promise(resolve =>
        setTimeout(resolve, Math.pow(2, attempt) * 1000)
      );
    }
  }
}

// Usage
try {
  const result = await chatWithRetry('Explain quantum computing');
  console.log(result);
} catch (error) {
  console.error('All retries failed:', error);
  // Implement your preferred recovery behavior (message, etc.)
}

import os
import time
from openai import OpenAI

client = OpenAI(
    api_key=os.environ['NORDLYS_API_KEY'],
    base_url='https://api.nordlyslabs.com/v1'
)

def chat_with_retry(message: str, max_retries: int = 3):
    for attempt in range(1, max_retries + 1):
        try:
            response = client.chat.completions.create(
                model='nordlys/hypernova',
                messages=[{'role': 'user', 'content': message}]
            )
            return response.choices[0].message.content

        except Exception as error:
            print(f"Attempt {attempt} failed: {error}")

            if attempt == max_retries:
                raise

            # Exponential backoff
            time.sleep(2 ** attempt)

# Usage
try:
    result = chat_with_retry('Explain quantum computing')
    print(result)
except Exception as error:
    print(f"All retries failed: {error}")
    # Implement recovery behavior

async function nordlysChat(messages, options = {}) {
  const { maxRetries = 3, recoveryMessage = 'Service temporarily unavailable' } = options;

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch('https://api.nordlyslabs.com/v1/chat/completions', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': 'Bearer apk_123456'
        },
        body: JSON.stringify({
          model: 'nordlys/hypernova',
          messages,
          temperature: 0.7
        })
      });

      if (!response.ok) {
        const errorData = await response.json();
        throw new Error(`API Error: ${errorData.error?.message || response.statusText}`);
      }

      const data = await response.json();
      return data.choices[0].message.content;

    } catch (error) {
      console.error(`Attempt ${attempt} failed:`, error.message);

      if (attempt === maxRetries) {
        return recoveryMessage;
      }

      // Exponential backoff
      await new Promise(resolve =>
        setTimeout(resolve, Math.pow(2, attempt) * 1000)
      );
    }
  }
}

// Usage
const messages = [{ role: 'user', content: 'Hello!' }];
const response = await nordlysChat(messages);
console.log(response);

Production Tip: Always log the request_id from error responses for debugging. For comprehensive error handling patterns, see the Error Handling Best Practices guide.

Example Response

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1677652288,
  "model": "gpt-5-nano",
  "choices": [{
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "Hello! I'm ready to help you."
    },
    "finish_reason": "stop"
  }],
  "usage": {
    "prompt_tokens": 5,
    "completion_tokens": 10,
    "total_tokens": 15
  }
}

{
  "id": "msg_abc123",
  "type": "message",
  "role": "assistant",
  "content": [{
    "type": "text",
    "text": "Hello! I'm ready to help you."
  }],
  "model": "claude-3-5-haiku",
  "stop_reason": "end_turn",
  "usage": {
    "input_tokens": 5,
    "output_tokens": 10
  }
}

Nordlys returns standard OpenAI or Anthropic-compatible responses.

Testing Your Integration

Send Test Request

Run your code with a simple message like “Hello!” to verify the connection

Check Response

Confirm you receive a response and check the model field in the response

Monitor Dashboard

View request logs and analytics in your Nordlys dashboard

Next Steps

Model Reference & Pricing

Learn about Nordlys model specifications and pricing

Integration Guides

Detailed guides for each SDK and framework

API Reference

Complete API documentation with all parameters

Code Examples

Working examples for common use cases

Need Help?

Troubleshooting

Common issues and their solutions

Support

Get help from our team

Getting Started

Developer Tools

Framework Integrations

API Reference

Support

Step 1: Get Your API Key

Step 2: Install SDK (Optional)

Authentication

Step 3: Make Your First Request

Error Handling

Example Response

Testing Your Integration

Next Steps

Model Reference & Pricing

Integration Guides

API Reference

Code Examples

Need Help?

Troubleshooting

Support

​Step 1: Get Your API Key

​Step 2: Install SDK (Optional)

​Authentication

​Step 3: Make Your First Request

​Error Handling

​Example Response

​Testing Your Integration

​Next Steps

Model Reference & Pricing

Integration Guides

API Reference

Code Examples

​Need Help?

Troubleshooting

Support

Step 1: Get Your API Key

Step 2: Install SDK (Optional)

Authentication

Step 3: Make Your First Request

Error Handling

Example Response

Testing Your Integration

Next Steps

Need Help?