SupaNexus
Get Started

Quickstart — Markdown source

Raw Markdown for copying or feeding to AI agents.

> **AI Agents**: Index `/api/llms.txt` | Full EN `/api/llms-full-en.txt` | Full ZH `/api/llms-full-zh.txt` | OpenAPI `/api/openapi.yaml`
> Base URL: `<BASE_URL>/v1`

# Quickstart

Get your first chat completion from SupaNexus in under two minutes.

## Prerequisites

1. Access to the SupaNexus API (see [Endpoints](./endpoints.md)).
2. A **project API key** created in the [Developer Console](https://console.supanexus.ai).

## Base URL

Examples below use the `<BASE_URL>` placeholder (usually with `/v1`):

```
<BASE_URL>/v1
```

> Fill `<BASE_URL>` from [Endpoints](./endpoints.md).

Replace `deepseek/deepseek-chat` with a model `id` from `GET /v1/models`.

## Send a chat completion

<!-- code-tabs default="curl" -->

```bash
export SNX_API_KEY="your-api-key"
export SNX_BASE_URL="<BASE_URL>/v1"

curl -s "${SNX_BASE_URL}/chat/completions" \
  -H "Authorization: Bearer ${SNX_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek/deepseek-chat",
    "messages": [{"role": "user", "content": "Say hello in one sentence."}]
  }'
```

```python
from openai import OpenAI

client = OpenAI(
    base_url="<BASE_URL>/v1",
    api_key="your-api-key",
)

completion = client.chat.completions.create(
    model="deepseek/deepseek-chat",
    messages=[{"role": "user", "content": "Say hello in one sentence."}],
)
print(completion.choices[0].message.content)
```

```typescript
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "<BASE_URL>/v1",
  apiKey: process.env.SNX_API_KEY,
});

const completion = await client.chat.completions.create({
  model: "deepseek/deepseek-chat",
  messages: [{ role: "user", content: "Say hello in one sentence." }],
});

console.log(completion.choices[0]?.message?.content);
```

```go
package main

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	apiKey := os.Getenv("SNX_API_KEY")
	baseURL := os.Getenv("SNX_BASE_URL") // <BASE_URL>/v1

	body := []byte(`{"model":"deepseek/deepseek-chat","messages":[{"role":"user","content":"Say hello in one sentence."}]}`)
	req, err := http.NewRequest(http.MethodPost, baseURL+"/chat/completions", bytes.NewReader(body))
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer "+apiKey)
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}
```

```java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Quickstart {
  public static void main(String[] args) throws Exception {
    String apiKey = System.getenv("SNX_API_KEY");
    String baseUrl = System.getenv("SNX_BASE_URL"); // <BASE_URL>/v1

    String json = """
      {"model":"deepseek/deepseek-chat","messages":[{"role":"user","content":"Say hello in one sentence."}]}
      """;

    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(baseUrl + "/chat/completions"))
        .header("Authorization", "Bearer " + apiKey)
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(json))
        .build();

    HttpResponse<String> response = HttpClient.newHttpClient()
        .send(request, HttpResponse.BodyHandlers.ofString());

    System.out.println(response.body());
  }
}
```

```c
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>

int main(void) {
  const char *api_key = getenv("SNX_API_KEY");
  const char *base_url = getenv("SNX_BASE_URL"); /* <BASE_URL>/v1 */

  CURL *curl = curl_easy_init();
  if (!curl) return 1;

  char url[512];
  snprintf(url, sizeof(url), "%s/chat/completions", base_url);

  struct curl_slist *headers = NULL;
  char auth[256];
  snprintf(auth, sizeof(auth), "Authorization: Bearer %s", api_key);
  headers = curl_slist_append(headers, auth);
  headers = curl_slist_append(headers, "Content-Type: application/json");

  const char *payload =
      "{\"model\":\"deepseek/deepseek-chat\",\"messages\":[{\"role\":\"user\",\"content\":\"Say hello in one sentence.\"}]}";

  curl_easy_setopt(curl, CURLOPT_URL, url);
  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);

  CURLcode res = curl_easy_perform(curl);
  curl_slist_free_all(headers);
  curl_easy_cleanup(curl);

  return res == CURLE_OK ? 0 : 1;
}
```

```javascript
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: process.env.SNX_BASE_URL ?? "<BASE_URL>/v1",
  apiKey: process.env.SNX_API_KEY,
});

const completion = await client.chat.completions.create({
  model: "deepseek/deepseek-chat",
  messages: [{ role: "user", content: "Say hello in one sentence." }],
});

console.log(completion.choices[0]?.message?.content);
```

```ruby
require "openai"

client = OpenAI::Client.new(
  access_token: ENV["SNX_API_KEY"],
  uri_base: ENV.fetch("SNX_BASE_URL", "<BASE_URL>/v1"),
)

response = client.chat(
  parameters: {
    model: "deepseek/deepseek-chat",
    messages: [{ role: "user", content: "Say hello in one sentence." }],
  },
)

puts response.dig("choices", 0, "message", "content")
```

```php
<?php

$baseUrl = getenv("SNX_BASE_URL") ?: "<BASE_URL>/v1";
$apiKey = getenv("SNX_API_KEY");

$ch = curl_init("{$baseUrl}/chat/completions");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer {$apiKey}",
        "Content-Type: application/json",
    ],
    CURLOPT_POSTFIELDS => json_encode([
        "model" => "deepseek/deepseek-chat",
        "messages" => [
            ["role" => "user", "content" => "Say hello in one sentence."],
        ],
    ]),
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
```

```rust
use reqwest::blocking::Client;
use std::env;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("SNX_API_KEY")?;
    let base_url = env::var("SNX_BASE_URL").unwrap_or_else(|_| "<BASE_URL>/v1".into());

    let client = Client::new();
    let response = client
        .post(format!("{base_url}/chat/completions"))
        .bearer_auth(api_key)
        .json(&serde_json::json!({
            "model": "deepseek/deepseek-chat",
            "messages": [{"role": "user", "content": "Say hello in one sentence."}]
        }))
        .send()?;

    println!("{}", response.text()?);
    Ok(())
}
```

```csharp
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

var apiKey = Environment.GetEnvironmentVariable("SNX_API_KEY");
var baseUrl = Environment.GetEnvironmentVariable("SNX_BASE_URL") ?? "<BASE_URL>/v1";

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);

var body = JsonSerializer.Serialize(new
{
    model = "deepseek/deepseek-chat",
    messages = new[] { new { role = "user", content = "Say hello in one sentence." } },
});

var response = await client.PostAsync(
    $"{baseUrl}/chat/completions",
    new StringContent(body, Encoding.UTF8, "application/json"));

Console.WriteLine(await response.Content.ReadAsStringAsync());
```

```kotlin
import java.net.URI
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse

fun main() {
    val apiKey = System.getenv("SNX_API_KEY")
    val baseUrl = System.getenv("SNX_BASE_URL") ?: "<BASE_URL>/v1"

    val json = """
      {"model":"deepseek/deepseek-chat","messages":[{"role":"user","content":"Say hello in one sentence."}]}
    """.trimIndent()

    val request = HttpRequest.newBuilder()
        .uri(URI.create("$baseUrl/chat/completions"))
        .header("Authorization", "Bearer $apiKey")
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(json))
        .build()

    val response = HttpClient.newHttpClient()
        .send(request, HttpResponse.BodyHandlers.ofString())

    println(response.body())
}
```

```swift
import Foundation

let apiKey = ProcessInfo.processInfo.environment["SNX_API_KEY"]!
let baseURL = ProcessInfo.processInfo.environment["SNX_BASE_URL"] ?? "<BASE_URL>/v1"

var request = URLRequest(url: URL(string: "\(baseURL)/chat/completions")!)
request.httpMethod = "POST"
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = """
{"model":"deepseek/deepseek-chat","messages":[{"role":"user","content":"Say hello in one sentence."}]}
""".data(using: .utf8)

let semaphore = DispatchSemaphore(value: 0)

URLSession.shared.dataTask(with: request) { data, _, _ in
    if let data, let text = String(data: data, encoding: .utf8) {
        print(text)
    }
    semaphore.signal()
}.resume()

semaphore.wait()
```

```scala
import java.net.URI
import java.net.http.{HttpClient, HttpRequest, HttpResponse}

@main def quickstart(): Unit =
  val apiKey = sys.env("SNX_API_KEY")
  val baseUrl = sys.env.getOrElse("SNX_BASE_URL", "<BASE_URL>/v1")
  val json =
    """{"model":"deepseek/deepseek-chat","messages":[{"role":"user","content":"Say hello in one sentence."}]}"""

  val request = HttpRequest.newBuilder()
    .uri(URI.create(s"$baseUrl/chat/completions"))
    .header("Authorization", s"Bearer $apiKey")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(json))
    .build()

  val response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString())

  println(response.body())
```

```dart
import 'dart:convert';
import 'dart:io';

Future<void> main() async {
  final apiKey = Platform.environment['SNX_API_KEY']!;
  final baseUrl = Platform.environment['SNX_BASE_URL'] ?? '<BASE_URL>/v1';

  final client = HttpClient();
  final request = await client.postUrl(Uri.parse('$baseUrl/chat/completions'));
  request.headers.set('Authorization', 'Bearer $apiKey');
  request.headers.contentType = ContentType.json;
  request.write(jsonEncode({
    'model': 'deepseek/deepseek-chat',
    'messages': [
      {'role': 'user', 'content': 'Say hello in one sentence.'},
    ],
  }));

  final response = await request.close();
  final body = await response.transform(utf8.decoder).join();
  print(body);
  client.close();
}
```

<!-- /code-tabs -->

## List available models

<!-- code-tabs default="curl" -->

```bash
curl -s "${SNX_BASE_URL}/models" \
  -H "Authorization: Bearer ${SNX_API_KEY}"
```

```python
from openai import OpenAI

client = OpenAI(
    base_url="<BASE_URL>/v1",
    api_key="your-api-key",
)

models = client.models.list()
for model in models.data:
    print(model.id)
```

```typescript
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: process.env.SNX_BASE_URL ?? "<BASE_URL>/v1",
  apiKey: process.env.SNX_API_KEY,
});

const models = await client.models.list();
for (const model of models.data) {
  console.log(model.id);
}
```

```javascript
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: process.env.SNX_BASE_URL ?? "<BASE_URL>/v1",
  apiKey: process.env.SNX_API_KEY,
});

const models = await client.models.list();
for (const model of models.data) {
  console.log(model.id);
}
```

```go
package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	apiKey := os.Getenv("SNX_API_KEY")
	baseURL := os.Getenv("SNX_BASE_URL") // <BASE_URL>/v1

	req, err := http.NewRequest(http.MethodGet, baseURL+"/models", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer "+apiKey)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}
```

```java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ListModels {
  public static void main(String[] args) throws Exception {
    String apiKey = System.getenv("SNX_API_KEY");
    String baseUrl = System.getenv("SNX_BASE_URL"); // <BASE_URL>/v1

    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(baseUrl + "/models"))
        .header("Authorization", "Bearer " + apiKey)
        .GET()
        .build();

    HttpResponse<String> response = HttpClient.newHttpClient()
        .send(request, HttpResponse.BodyHandlers.ofString());

    System.out.println(response.body());
  }
}
```

```c
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>

int main(void) {
  const char *api_key = getenv("SNX_API_KEY");
  const char *base_url = getenv("SNX_BASE_URL"); /* <BASE_URL>/v1 */

  CURL *curl = curl_easy_init();
  if (!curl) return 1;

  char url[512];
  snprintf(url, sizeof(url), "%s/models", base_url);

  struct curl_slist *headers = NULL;
  char auth[256];
  snprintf(auth, sizeof(auth), "Authorization: Bearer %s", api_key);
  headers = curl_slist_append(headers, auth);

  curl_easy_setopt(curl, CURLOPT_URL, url);
  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

  CURLcode res = curl_easy_perform(curl);
  curl_slist_free_all(headers);
  curl_easy_cleanup(curl);

  return res == CURLE_OK ? 0 : 1;
}
```

```ruby
require "openai"

client = OpenAI::Client.new(
  access_token: ENV["SNX_API_KEY"],
  uri_base: ENV.fetch("SNX_BASE_URL", "<BASE_URL>/v1"),
)

response = client.models.list
response["data"].each { |model| puts model["id"] }
```

```php
<?php

$baseUrl = getenv("SNX_BASE_URL") ?: "<BASE_URL>/v1";
$apiKey = getenv("SNX_API_KEY");

$ch = curl_init("{$baseUrl}/models");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer {$apiKey}",
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
```

```rust
use reqwest::blocking::Client;
use std::env;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("SNX_API_KEY")?;
    let base_url = env::var("SNX_BASE_URL").unwrap_or_else(|_| "<BASE_URL>/v1".into());

    let client = Client::new();
    let response = client
        .get(format!("{base_url}/models"))
        .bearer_auth(api_key)
        .send()?;

    println!("{}", response.text()?);
    Ok(())
}
```

```csharp
using System.Net.Http.Headers;

var apiKey = Environment.GetEnvironmentVariable("SNX_API_KEY");
var baseUrl = Environment.GetEnvironmentVariable("SNX_BASE_URL") ?? "<BASE_URL>/v1";

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);

var response = await client.GetAsync($"{baseUrl}/models");
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

```kotlin
import java.net.URI
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse

fun main() {
    val apiKey = System.getenv("SNX_API_KEY")
    val baseUrl = System.getenv("SNX_BASE_URL") ?: "<BASE_URL>/v1"

    val request = HttpRequest.newBuilder()
        .uri(URI.create("$baseUrl/models"))
        .header("Authorization", "Bearer $apiKey")
        .GET()
        .build()

    val response = HttpClient.newHttpClient()
        .send(request, HttpResponse.BodyHandlers.ofString())

    println(response.body())
}
```

```swift
import Foundation

let apiKey = ProcessInfo.processInfo.environment["SNX_API_KEY"]!
let baseURL = ProcessInfo.processInfo.environment["SNX_BASE_URL"] ?? "<BASE_URL>/v1"

var request = URLRequest(url: URL(string: "\(baseURL)/models")!)
request.httpMethod = "GET"
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")

let semaphore = DispatchSemaphore(value: 0)

URLSession.shared.dataTask(with: request) { data, _, _ in
    if let data, let text = String(data: data, encoding: .utf8) {
        print(text)
    }
    semaphore.signal()
}.resume()

semaphore.wait()
```

```scala
import java.net.URI
import java.net.http.{HttpClient, HttpRequest, HttpResponse}

@main def listModels(): Unit =
  val apiKey = sys.env("SNX_API_KEY")
  val baseUrl = sys.env.getOrElse("SNX_BASE_URL", "<BASE_URL>/v1")

  val request = HttpRequest.newBuilder()
    .uri(URI.create(s"$baseUrl/models"))
    .header("Authorization", s"Bearer $apiKey")
    .GET()
    .build()

  val response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString())

  println(response.body())
```

```dart
import 'dart:convert';
import 'dart:io';

Future<void> main() async {
  final apiKey = Platform.environment['SNX_API_KEY']!;
  final baseUrl = Platform.environment['SNX_BASE_URL'] ?? '<BASE_URL>/v1';

  final client = HttpClient();
  final request = await client.getUrl(Uri.parse('$baseUrl/models'));
  request.headers.set('Authorization', 'Bearer $apiKey');

  final response = await request.close();
  final body = await response.transform(utf8.decoder).join();
  print(body);
  client.close();
}
```

<!-- /code-tabs -->

## Next steps

- [Authentication](./authentication.md) — API key format and errors
- [Chat Completions](./chat-completions.md) — full request/response reference
- [OpenAI SDK Integration](./openai-sdk-integration.md) — drop-in migration guide