1StopTek

Developer services

Developers

Build on the 1StopTek ecosystem.

Integrate communication, AI and data infrastructure into your applications through 1StopTek developer services.

1st AI Platform API

In testing

Build with the 1st AI Platform API.

A versioned HTTPS API for chat completions, streaming, structured output and embeddings, served by the platform 1StopTek operates.

Restricted testing

Access is limited to invited testers. The planned staging host is not online yet, and no model is connected: inference requests return 503 inference_unavailable. Nothing is charged.

Capabilities

Capabilities
CapabilityStatusDetails
Chat completionsIn testingPOST /api/v1/chat/completions with system, user and assistant messages; temperature, top_p, max_tokens and stop.
StreamingIn testingServer-sent events (stream: true): chat.completion.chunk events, then data: [DONE].
Structured outputIn testingresponse_format json_object or json_schema; the result is validated against your schema. Not combinable with streaming.
EmbeddingsIn testingPOST /api/v1/embeddings, up to 64 inputs of up to 8,000 characters each.
Model discoveryIn testingGET /api/v1/models lists each model with its capabilities, context window and output limit.
Usage APIIn testingGET /api/v1/usage returns a project's daily token counts and month-to-date totals.
Document retrieval (RAG)PlannedImplemented inside Eurylie with citations; not yet exposed on the Developer API.
Tool and function callingPlannedRequests that use tools are rejected with an explicit error, never silently ignored.
Image and audio inputNot supportedText only. Non-text content is rejected with unsupported_content_type.

Models and their limits

The platform serves open-weight models on its own inference hardware. GET /api/v1/models is the authoritative list for each environment: every entry states its capabilities, context window and maximum output tokens.

Context window
Per model, reported by GET /api/v1/models. Planned staging configuration: 4,096 tokens, prompt and output together.
Maximum output per request
The lower of your tier's limit (1,024 in sandbox, 4,096 in higher tiers) and the model's own limit (1,024 in the planned staging configuration).
Messages per request
up to 256
Embeddings per request
64 inputs, 8,000 characters each

Throughput and latency have not been benchmarked on the production inference hardware yet. We will publish measured figures, not targets.

Safety Layer

Inputs and outputs pass the platform's Safety Layer. A refused request returns safety_error; a refused output ends with finish_reason content_filter.

APIs and documentation

APIs and documentation

The Developer API is HTTPS and JSON, with an OpenAPI 3.1 description generated from the same contract the server is tested against.

Base URLs

URL
Staging (testing)https://platform-api-staging.1stoptek.comPlanned host, not online yet. Invited testers only; no model is connected yet
Productionhttps://api.1stoptek.comNot open yet · live keys (1stai_live_…) only

Authentication

Send your project API key as a bearer token: Authorization: Bearer 1stai_test_…. Call the API from your server only; never ship a key to a browser or mobile app.

Quick start

Restricted testing

Testing is by invitation. Approved testers sign in to the console, declare their age once (required on staging) and can create organizations, projects and test keys. Until a safety-qualified model is connected, chat, streaming and embeddings requests return 503 inference_unavailable, and nothing is charged.
  1. Ask for tester access (developers@1stoptek.com), then create a 1StopTek account and verify your email address.
  2. Open the developer console and create an organization; it starts with a Default project.
  3. Create an API key for the project. Copy it now: it is shown once.
  4. Export it as FIRSTAI_API_KEY and send your first request.
Shell
export FIRSTAI_BASE_URL=https://platform-api-staging.1stoptek.com
export FIRSTAI_API_KEY=1stai_test_...   # from the developer console
Chat completion · curl
curl -sS "$FIRSTAI_BASE_URL/api/v1/chat/completions" \
  -H "Authorization: Bearer $FIRSTAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "system", "content": "You answer in one sentence."},
      {"role": "user", "content": "What is an API key?"}
    ],
    "max_tokens": 120
  }'
Streaming · curl
curl -sS -N "$FIRSTAI_BASE_URL/api/v1/chat/completions" \
  -H "Authorization: Bearer $FIRSTAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [{"role": "user", "content": "Count from one to five."}],
    "max_tokens": 60,
    "stream": true
  }'
# data: {"object":"chat.completion.chunk","choices":[{"delta":{"content":"One"},...}]}
# ...
# data: [DONE]
Embeddings · curl
curl -sS "$FIRSTAI_BASE_URL/api/v1/embeddings" \
  -H "Authorization: Bearer $FIRSTAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input": ["first document", "second document"]}'
Structured output · curl
curl -sS "$FIRSTAI_BASE_URL/api/v1/chat/completions" \
  -H "Authorization: Bearer $FIRSTAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [{"role": "user", "content": "Extract: Berlin is the capital of Germany."}],
    "max_tokens": 120,
    "response_format": {
      "type": "json_schema",
      "json_schema": {
        "name": "fact",
        "schema": {
          "type": "object",
          "properties": {"city": {"type": "string"}, "country": {"type": "string"}},
          "required": ["city", "country"]
        }
      }
    }
  }'
Python (standard library)
import json, os, urllib.request

req = urllib.request.Request(
    os.environ["FIRSTAI_BASE_URL"] + "/api/v1/chat/completions",
    method="POST",
    headers={
        "Authorization": "Bearer " + os.environ["FIRSTAI_API_KEY"],
        "Content-Type": "application/json",
    },
    data=json.dumps({
        "messages": [{"role": "user", "content": "Say hello."}],
        "max_tokens": 60,
    }).encode(),
)
try:
    with urllib.request.urlopen(req, timeout=120) as resp:
        body = json.load(resp)
        print(body["choices"][0]["message"]["content"])
        print(body["usage"])
except urllib.error.HTTPError as err:
    error = json.load(err)["error"]
    print(err.code, error["type"], error["code"], error["request_id"])
JavaScript (Node.js 18+, no dependencies)
const res = await fetch(`${process.env.FIRSTAI_BASE_URL}/api/v1/chat/completions`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.FIRSTAI_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    messages: [{ role: "user", content: "Say hello." }],
    max_tokens: 60,
  }),
});
const body = await res.json();
if (!res.ok) {
  const { type, code, request_id } = body.error;
  throw new Error(`${res.status} ${type}/${code} (request ${request_id})`);
}
console.log(body.choices[0].message.content, body.usage);

There is no separate SDK package yet. The examples use plain HTTP; because the request and response shapes follow the widely used chat-completions format, many existing client libraries work by changing the base URL. We document only clients we have tested.

Request limits

Each project has a requests-per-minute bucket and each organization a monthly token allowance, set by its tier. Every response reports the remaining requests in X-RateLimit-Limit-Requests and X-RateLimit-Remaining-Requests; a 429 carries Retry-After.

TierRequests per minute (per project)Tokens per month (per organization)Max output tokensConcurrent streams
sandbox20500,0001,0242
developer12010,000,0004,09610
scale600100,000,0004,09650
enterprise3,0001,000,000,0004,096200

New organizations start in sandbox. Tiers are limits, not prices; higher tiers are assigned after review.

Errors

Every error has the same JSON shape. Branch on type; log request_id when you contact support. Messages never contain your prompt.

JSON
{"error": {"type": "rate_limit_error", "code": "rate_limited",
  "message": "project limit of 20 requests per minute reached",
  "param": null, "request_id": "req_…", "retry_after_seconds": 3}}
HTTPtypeTypical codes
400invalid_request_errorinvalid_messages, unsupported_parameter, context_length_exceeded
401authentication_errorinvalid_api_key
402quota_exceeded_errormonthly_quota_exceeded, spending_limit_reached
403permission_errorforbidden, organization_suspended
404not_found_errormodel_not_found
409conflict_errorkey_limit_reached, project_archived
422safety_errorsafety_refused
429rate_limit_errorrate_limited, too_many_streams
502 / 504model_errormodel_error, model_timeout, invalid_structured_output
503service_unavailable_errormodel_unavailable, billing_unavailable

Retries

Retry 429 after Retry-After, and 502/503/504 with exponential backoff. Do not retry 4xx validation errors unchanged. Each attempt is a separate request and is metered on its own.

Versioning

The major version is in the path (/api/v1) and in the X-API-Version header. Within v1 we only add: new endpoints, new optional fields and new enum values. Clients must ignore unknown fields. A breaking change ships as /api/v2, announced in advance with a deprecation period for v1.

Developer account and API keys

Developer account and API keys

One 1StopTek account signs you in. Organizations, projects and keys belong to the platform; the console manages them for you.

From sign-up to first request

  1. 01

    Create account

    Testing is by invitation: ask for tester access, then sign up with email and password.

  2. 02

    Verify email

    Follow the link we send. Unverified accounts cannot reach the console.

  3. 03

    Create organization

    You become its owner. A Default project is created with it.

  4. 04

    Generate API key

    Choose name, scopes and optional expiry. The full key is shown once.

  5. 05

    Make first request

    Use the quick start with your key.

  6. 06

    View usage and costs

    Tokens, requests and estimated charges per project and key.

How API keys are protected

  • Keys look like 1stai_test_<id>_<secret>. Staging issues test keys only; production issues live keys only, and neither works in the other environment.
  • The full key is shown exactly once, when it is created or rotated. Afterwards the console shows only a short hint.
  • The platform stores a keyed hash (HMAC-SHA-256 with a server-side secret), never the key. A database copy alone cannot be used to authenticate.
  • Keys are scoped to one project and carry only the scopes you choose: models:read, chat:write, embeddings:write, usage:read.
  • Revocation takes effect on the next request. Rotation issues a replacement and keeps the old key working for a grace period you choose (up to 7 days, or 0 to revoke immediately).
  • Organizations are isolated from each other: every console and API call is checked against the organization the key or account belongs to.

Website assistants

Website assistants for developers

The technical details behind the guided setup in the console.

Example only: website assistants aren't available to customers yet.

The installation code

The code identifies the assistant with its public assistant id. It contains no key. The assistant accepts browser requests only from the exact https origins of websites whose ownership was confirmed. A program outside a browser can imitate an origin, so per-visitor limits, per-assistant limits and your spending limit apply as well.

HTML
<script src="https://{widget-host}/widget/v1/agent.js" data-agent="agt_…" async></script>

The widget host isn't decided yet; the code shows a placeholder.

Pinned version with Subresource Integrity

The stable path follows compatible widget updates. To pin one release, use the versioned path and the integrity hash published in the widget's manifest.json.

HTML
<script src="https://{widget-host}/widget/v1/{version}/agent.js"
        integrity="sha384-…" crossorigin="anonymous"
        data-agent="agt_…" async></script>

Options

  • data-locale="de" sets the language.
  • An element with id="1stai-agent" shows the assistant inline instead of floating.
  • With a Content Security Policy, allow the platform origin in script-src and connect-src, and inline styles for the widget's own style element.

Server-to-server (Advanced settings)

An agents:invoke key is bound to the assistants you choose and has no other permission. Keep it on your server; never put it in a web page.

Usage and billing

Usage and billing

Metering happens on the server, per request, at the moment a request completes. The console shows exactly what the platform recorded.

What is metered

  • One record per request: organization, project, key id, endpoint, model, status, input and output tokens, latency. No prompt or output content.
  • Token counts come from the model server where it reports them; otherwise they are estimated and marked as estimated.
  • Retrying with a new request creates a new record. Repeating the same request id is never counted twice.

What you see in the console

  • Month-to-date tokens and requests against your allowance, per project and per key.
  • Estimated current charges once a rate card applies, with net, VAT and gross shown separately.
  • Monthly statements for closed months. Invoices are not issued yet; they will be once paid access opens.

Alerts and spending limits

Alert threshold

Records an alert when month-to-date usage cost (before the included allowance) crosses the amount. Requests keep working.

Hard spending limit

Requests that could take month-to-date usage cost (before the included allowance) over the limit are refused with 402 spending_limit_reached before the model is called.

Requests in flight

Before calling a model, the platform reserves the request's worst-case cost (input plus your max_tokens). Requests already admitted finish normally, and their actual cost never exceeds what was reserved, so concurrent requests cannot jointly exceed a hard limit. A request that could exceed the remaining budget is refused even if its actual cost would have been lower.

If usage cannot be checked

If the platform cannot read usage, holds or limits, it refuses the request with 503 billing_unavailable. A failed lookup never grants unlimited access.

API v1 · contract 0b847d90d1

PulseChat Business API

Implemented, not enabled

Business messaging for the systems you already run.

Verified businesses will connect their shop, ticketing or booking system to PulseChat: to answer the support conversations their customers start, and to send transactional updates to customers who opted in.

The business API is implemented and tested, but it is not enabled yet and has no external developers. Setup, the sandbox and live access are not open; this page will say when that changes.

Two supported ways to message

Replies to support conversations

A customer opens a conversation with your business in PulseChat. Your system can read it and reply. Your business cannot start these conversations.

Transactional updates

Order, service, appointment and account updates, sent with templates PulseChat has approved, only to customers who opted in to updates from your business. Customers can withdraw at any time. The final opt-in model is under legal review.

What exists and its status

  • Replies to customer-started conversationsImplemented, not enabled
  • Transactional updates to opted-in customersImplemented, not enabled
  • Templates with PulseChat reviewImplemented, not enabled
  • Sandbox with synthetic customersImplemented, not enabled
  • Narrowly scoped API keys with rotation and revocationImplemented, not enabled
  • Signed webhooksImplemented, not enabled
  • Event pollingImplemented, not enabled
  • Usage limitsImplemented, not enabled
  • Live access after PulseChat approvalImplemented, not enabled
  • Website chatPlanned

What the API will not do

  • Start a conversation or write to customers who neither wrote first nor opted in
  • Write to customers who blocked the business or withdrew their opt-in
  • Send marketing or bulk messages
  • Send sign-in or verification codes

How customers are referenced

Your system sees a customer only through a reference specific to your business, not their phone number, PulseChat ID or name. That is not anonymity: customers can still share personal details in their own messages.

Setup is not open yet

Guided setup and the developer documentation will be published once PulseChat opens the API. If you want to be considered for the pilot, get in touch.

Built for real workflows

E-commerce

  1. Order confirmation
  2. Shipping update
  3. Delivery update
  4. Reply to the customer's question

SaaS

Account and service updates, and replies to support conversations your customers start.

Booking

Confirmations, reminders, changes and cancellations.

Marketplaces

Order and support messages between a marketplace and its own customers, without sharing customers' phone numbers.

How a message travels
  1. Your server
  2. PulseChat Business API
  3. PulseChat
  4. Your customer

1Stop DataHub

Planned

The developer and business control layer for the 1StopTek ecosystem.

One place to manage the 1StopTek integrations your organization uses — applications, credentials, teams and usage.

One account. Multiple products. One platform.

Developers and organizations will manage supported 1StopTek integrations from one environment. The control-plane foundations underneath — identity, roles and permissions, entitlements, auditing — are in active development; DataHub is the planned product on top of them.

What it will manage

  • Applications
  • API credentials
  • Webhooks
  • Teams
  • Roles and permissions
  • API usage
  • Analytics
  • Subscriptions and billing
  • Integrations
  • Supported 1StopTek services
One control layer
Your Application1Stop DataHubPulseChat · 1st AI Platform · future 1StopTek APIs

Developer services

Business or Developers?

1StopTek Developers

For developers integrating 1StopTek technology into applications and services.

1Stop DataHub

The planned technical management layer connecting applications, credentials, permissions, usage and supported ecosystem services.

Build with 1StopTek

Developer access to the PulseChat Business API, the 1st AI Platform API and 1Stop DataHub is being prepared. If you are a developer, a business or an integration partner, talk to us about early access, API integrations, enterprise integrations and partnerships.

developers@1stoptek.com