Marketplace Quickstart

This guide walks you through obtaining a token using Client Credentials authentication and conversing with an agent via SSE.

Introduction

Here are the quickest steps to use the Marketplace API. You can start conversing with an agent in just three steps.

Prerequisites

• Setup of the AgenticStar environment purchased from Marketplace is complete
• A service account has been created in the Admin panel
• You have Client ID, Client Secret, and Agent ID

Step 1: Verify Authentication Information

Before using the API, confirm you have the following information. These can be verified in the Admin panel.

Preparation Checklist

• Setup of the AgenticStar environment purchased from Marketplace is complete
• A service account has been created in the Admin panel
• You have obtained the following information:
  • Client ID - Client ID of the service account
  • Client Secret - Secret of the service account (verify in Admin details screen)
  • Agent ID - ID of the agent to use

Authentication Information Example

Client ID: mp-service-001
Client Secret: (hidden)
Agent ID: agent-ai-bot

Step 2: Obtain Token

Use the Client Credentials flow to obtain an access token. Execute the following request from your server.

Request Example

curl

curl

curl -X POST https://<your-domain>/api/v1/auth/external-service-token \
  -H "Content-Type: application/json" \
  -d '{
    "client_id": "<your-client-id>",
    "client_secret": "<your-client-secret>"
  }'

Python

Python

import requests

response = requests.post(
    "https://<your-domain>/api/v1/auth/external-service-token",
    json={
        "client_id": "<your-client-id>",
        "client_secret": "<your-client-secret>",
    },
)
token = response.json()["access_token"]
print(token)

TypeScript

TypeScript

const response = await fetch(
  "https://<your-domain>/api/v1/auth/external-service-token",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      client_id: "<your-client-id>",
      client_secret: "<your-client-secret>",
    }),
  }
);

const { access_token } = await response.json();
console.log(access_token);

Go

Go

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    body, _ := json.Marshal(map[string]string{
        "client_id":     "<your-client-id>",
        "client_secret": "<your-client-secret>",
    })

    resp, _ := http.Post(
        "https://<your-domain>/api/v1/auth/external-service-token",
        "application/json",
        bytes.NewReader(body),
    )
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Println(result["access_token"])
}

Parameters

• <your-domain>: Base URL verified in Step 1 (example: api.example.com)
• <your-client-id>: Client ID verified in Step 1
• <your-client-secret>: Secret verified in Step 1

Response Example

JSON

{
  "access_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
  "token_type": "Bearer",
  "expires_in": 3600
}

Token Expiration

The token is valid for the number of seconds specified in expires_in. Obtain a new token before expiration. The Client Credentials flow does not issue refresh tokens, so after expiration, execute the same request again.

Step 3: Call Chat API

Use the obtained access token to call the Chat API via SSE (Server-Sent Events). You will receive real-time responses from the agent in stream format.

Request Example

curl

curl

curl -X POST https://<your-domain>/api/v1/chat/completions \
  -H "Authorization: Bearer <access_token>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "AGENTIC STAR",
    "stream": true,
    "agentId": "<your-agent-id>",
    "messages": [
      {
        "role": "user",
        "content": "こんにちは"
      }
    ]
  }'

Python

Python

import requests
import json

response = requests.post(
    "https://<your-domain>/api/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
    },
    json={
        "model": "AGENTIC STAR",
        "stream": True,
        "agentId": "<your-agent-id>",
        "messages": [{"role": "user", "content": "こんにちは"}],
    },
    stream=True,
)

for line in response.iter_lines():
    if line:
        data = line.decode("utf-8")
        if data == "data: [DONE]":
            break
        if data.startswith("data: "):
            chunk = json.loads(data[6:])
            content = chunk["choices"][0]["delta"].get("content", "")
            print(content, end="", flush=True)

TypeScript

TypeScript

const response = await fetch(
  "https://<your-domain>/api/v1/chat/completions",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${accessToken}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "AGENTIC STAR",
      stream: true,
      agentId: "<your-agent-id>",
      messages: [{ role: "user", content: "こんにちは" }],
    }),
  }
);

const reader = response.body?.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader?.read() || { done: true };
  if (done) break;
  for (const line of decoder.decode(value).split("\n")) {
    if (line.startsWith("data: ") && line !== "data: [DONE]") {
      const chunk = JSON.parse(line.slice(6));
      process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
    }
  }
}

Go

Go

package main

import (
    "bufio"
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "strings"
)

func main() {
    body, _ := json.Marshal(map[string]interface{}{
        "model":   "AGENTIC STAR",
        "stream":  true,
        "agentId": "<your-agent-id>",
        "messages": []map[string]string{
            {"role": "user", "content": "こんにちは"},
        },
    })

    req, _ := http.NewRequest("POST",
        "https://<your-domain>/api/v1/chat/completions",
        bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+token)
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    scanner := bufio.NewScanner(resp.Body)
    for scanner.Scan() {
        line := scanner.Text()
        if strings.HasPrefix(line, "data: ") {
            data := line[6:]
            if data == "[DONE]" { break }
            fmt.Print(data)
        }
    }
}

Parameters

• <access_token>: Access token obtained in Step 2
• <your-agent-id>: Agent ID verified in Step 1
• stream: true: Enable SSE streaming
• messages: Message from user. Multiple messages can be sent in array format

Response Example (SSE Stream)

data: {"choices":[{"delta":{"content":"Hello"}}]}

data: {"choices":[{"delta":{"content":", how can I"}}]}

data: {"choices":[{"delta":{"content":"help you?"}}]}

data: [DONE]

About SSE Streaming

The response is in Server-Sent Events (SSE) format, sent in real-time in chunks. Each chunk is in the format data: JSON. The conversation completes with data: [DONE]. See Streaming Guide for details.

Next Steps

For more detailed information and implementation patterns, see the following documentation.

⚡Streaming Guide

Marketplace

SSE connection lifecycle, event handling, reconnection, error handling

📘API Reference

Marketplace

Endpoint specifications, request/response formats, error codes

🔑Authentication Reference

Marketplace

JWT structure, Realm configuration, token endpoint specifications