SDKs

Official client libraries are available for five languages. Every SDK wraps the same REST endpoints, sends your API key automatically, and returns the same envelope shape as the raw API.

New — the JavaScript SDK is the most complete and the one we build against first. Start there if you are unsure which to pick.

JavaScript

Node.js 18+ and modern browsers. ESM and TypeScript types included.

Python

Python 3.9+. No third-party dependencies.

PHP

PHP 8.1+. Composer package.

C#

.NET 6+.

Go

Go 1.21+. Single module, zero dependencies.

Install

JavaScript
Python
PHP
C#
Go

Useing npm:

npm i @octaviatech/cms

Useing yarn:

yarn add @octaviatech/cms

Useing pnpm:

pnpm install @octaviatech/cms

 pip install octavia-cms-sdk

composer require octavia/cms

dotnet add package Octavia.CmsSDK

go get

https://github.com/octaviatech/octavia-ai-cms/tree/main/packages/sdk-go/sdk

Quick start

Every SDK is initialized with your API key. The base URL is fixed to the production endpoint, so the only required value is the key.

JavaScript
Python
PHP
C#
Go

import { CMS } from "@octaviatech/cms";

const cms = CMS.init("0x-OCT...");

const res = await cms.article.getAll({ query: { page: 1, limit: 10 } });
if (res.ok) {
  console.log(res.data);
} else {
  console.error(res.error?.message);
}

from octavia_cms_sdk import CMS

cms = CMS.init("0x-OCT...")

res = cms.article.getAll(query={"page": 1, "limit": 10})
if res.ok:
    print(res.data)
else:
    print(res.error)

use Octavia\CmsSDK\CMS;

$cms = CMS::init("0x-OCT...");

$res = $cms->article->getAll(['page' => 1, 'limit' => 10]);
if ($res->success) {
    print_r($res->data);
} else {
    print_r($res->message);
}

using Octavia.CmsSDK;

var cms = CMS.Init("0x-OCT...");

var res = await cms.Article.GetAllAsync(new Dictionary<string, string?>
{
    ["page"] = "1",
    ["limit"] = "10",
});
if (res.Ok) Console.WriteLine(res.Data);
else Console.Error.WriteLine(res.Error?.Message);

package main

import (
    "fmt"

    "https://github.com/octaviatech/octavia-ai-cms/tree/main/packages/sdk-go/sdk"
)

func main() {
    cms, err := sdk.InitCMS("0x-OCT...", nil)
    if err != nil {
        panic(err)
    }

    res := cms.Article.GetAll(map[string]any{"page": 1, "limit": 10})
    fmt.Println(res.Data)
}

Authentication

The only thing you need to configure is your API key. It is sent on every request as the x-api-key header, and the SDKs do not expose any other header configuration — there is nothing else for a caller to set.

Multi-tenancy headers are injected by the API gateway on your behalf. You never pass them, and no SDK option accepts them.

Keep the key out of source control. Read it from the environment in every language:

JavaScript
Python
PHP
C#
Go

const cms = CMS.init(process.env.OCTAVIA_API_KEY!);

import os

cms = CMS.init(os.environ["OCTAVIA_API_KEY"])

$cms = CMS::init(getenv('OCTAVIA_API_KEY'));

var cms = CMS.Init(Environment.GetEnvironmentVariable("OCTAVIA_API_KEY")!);

key := os.Getenv("OCTAVIA_API_KEY")
cms, err := sdk.InitCMS(key, nil)

Response shape

Every endpoint returns the same wire envelope — { success, statusCode, message, data } — and each SDK re-wraps it into a result object. See Response format for the raw structure.

Language	Success	Payload	Error	Pagination
JavaScript	`res.ok`	`.data`	`.error.message`	`res.meta.pagination`
Python	`res.ok`	`.data`	`.error`	`res.meta["pagination"]`
PHP	`$res.success`	`$res.data`	`$res.message`	`$res.data.pagination`
C#	`res.Ok`	`.Data`	`.Error.Message`	`res.Meta.Pagination`
Go	`res.Ok`	`.Data`	`.Error.Message`	`res.Meta.Pagination`

PHP is the exception. The PHP SDK has no wrapper at all — CMS::init returns the raw Envelope, so there is no ok, no error object and no meta. Read $res->success and $res->message, and read pagination from $res->data.

meta is absent entirely when a response carries no pagination, and Python is the only language that renames totalPages to total_pages.

By default an API error is a normal return value, not an exception. Set the throw-on-error option to raise instead:

JavaScript
Python
PHP
C#
Go

const cms = CMS.init(process.env.OCTAVIA_API_KEY!, { throwOnError: true });

cms = CMS.init(key, throw_on_error=True)

$cms = CMS::init($key, ['throwOnError' => true]);

var cms = CMS.Init(key, new CMSOptions { ThrowOnError = true });

cms, err := sdk.InitCMS(key, &sdk.CMSOptions{ThrowOnError: true})

The Go SDK’s ThrowOnError panics rather than returning an error, and the panic value is a plain string — recover with defer/recover if you enable it.

Resources

The names below are the same across all five SDKs. Method names differ only in capitalisation convention.

Resource	Access	Covers
`article`	`.article`	Articles: CRUD, search, publish state, SEO analysis
`author`	`.author`	Author profiles
`category`	`.category`	Categories
`subcategory`	`.subcategory`	Subcategories
`form`	`.form`	Forms, captcha config
`formSubmission`	`.formSubmission`	Form submissions
`language`	`.language`	Languages
`tag`	`.tag`	Tags
`report`	`.report`	Statistics, dashboards, charts
`ai`	`.ai`	Summarize, translate, SEO, repurpose, social publish
`aiConversation`	`.aiConversation`	Chat sessions and messages
`raw`	`.raw`	The underlying HTTP client, for unlisted endpoints

The JS and Go SDKs are generated from the OpenAPI spec and cover the full surface, including AI conversation, meta and tags. The Python, PHP and C# SDKs expose the resources above; for anything outside them, call through raw.

Configuration

JavaScript
Python
PHP
C#
Go

const cms = CMS.init(key, {
  timeoutMs: 30_000,     // default
  throwOnError: false,   // default
});

cms = CMS.init(key, timeout_ms=30_000, throw_on_error=False)

$cms = CMS::init($key, ['timeoutMs' => 0, 'throwOnError' => false]);

var cms = CMS.Init(key, new CMSOptions
{
    Timeout = TimeSpan.FromSeconds(30),
    ThrowOnError = false,
});

client, err := sdk.NewClient(sdk.ClientConfig{
    BaseURL: sdk.CMSBaseURL,
    ApiKey:  key,
    Timeout: 30 * time.Second,
})

In the PHP SDK timeoutMs defaults to 0, which means no timeout. Set it explicitly in production.

Retry and rate limits

None of the SDKs retry automatically. A 429 is returned as a normal error result, so you can inspect the status and back off yourself:

JavaScript
Python

const res = await cms.article.getAll();
if (!res.ok && res.error?.statusCode === 429) {
  await new Promise((r) => setTimeout(r, 1000));
}

import time

res = cms.article.getAll()
if not res.ok and res.error and res.error.get("statusCode") == 429:
    time.sleep(1)

429 details are only available where the SDK exposes the status code — the error.statusCode on the returned result. Elsewhere, use a fixed backoff.

For AI agents

Agent skill

A rule-shaped file that stops an agent from inventing method names, misreading pagination, or setting headers the gateway owns.

Using these files

How to load the skill and llms.txt into an agent, and which one to load when.

Support

Need something not covered here? Open a ticket with the operation you called, your SDK version, and the request ID from the response headers.

Dashboard

Manage API keys and inspect usage.

Support

Reach the engineering team.

Get started

How to use

Build with LLMs

Languages

Content Management

Forms

AI Automation

Social Publishing

Analytics

AI Automation

AI Conversation

Articles

Authors

Categories

Forms

Form Submissions

Languages

Reports

Subcategories

Tags

SDKs

JavaScript

Python

PHP

C#

Go

Install

Quick start

Authentication

Response shape

Resources

Configuration

Retry and rate limits

For AI agents

Agent skill

Using these files

Support

Dashboard

Support

JavaScript

Python

PHP

C#

Go

​Install

​Quick start

​Authentication

​Response shape

​Resources

​Configuration

​Retry and rate limits

​For AI agents

Agent skill

Using these files

​Support

Dashboard

Support

Install

Quick start

Authentication

Response shape

Resources

Configuration

Retry and rate limits

For AI agents

Support