SDKs

Ripllo ships SDKs in three languages, with feature parity across all three. Pick the one for your stack:

Language	Package	Install
Node.js	`@forjio/ripllo-node`	`npm install @forjio/ripllo-node`
Python	`ripllo`	`pip install ripllo`
Go	`github.com/hachimi-cat/ripllo-go`	`go get github.com/hachimi-cat/ripllo-go`

All three:

Implement the same surface: every API resource is exposed as a typed method.
Handle HMAC signing automatically — you provide the key, they sign every request.
Provide a verifyWebhook helper for inbound events.
Use only minimal dependencies (Node: zero runtime deps, uses the built-in fetch; Python: httpx; Go: stdlib).
Are open source: the sources live in the Ripllo monorepo under sdk/<lang>/ and are mirrored one-way to the per-language repos (ripllo-node, ripllo-python, ripllo-go), which is what the package registries build from.

When to use which

If your existing stack is in Node, Python, or Go: use the matching SDK. There's no perf or feature reason to use one over another — pick your language.

If your stack is in another language (Ruby, PHP, Rust, Java, Elixir, etc.): use the raw API. HMAC signing is straightforward.

Quick comparison

Same call in three languages — create a discount code:

Node.js:

import { RiplloClient } from '@forjio/ripllo-node';

const ripllo = new RiplloClient({
  keyId: process.env.RIPLLO_KEY_ID,
  secret: process.env.RIPLLO_KEY_SECRET,
});

const code = await ripllo.discountCodes.create({
  code: 'WELCOME10',
  type: 'percent',
  value: 10,
  currency: 'IDR',
  scope: 'cart',
});

Python:

from ripllo import RiplloClient
import os

ripllo = RiplloClient(
    key_id=os.environ["RIPLLO_KEY_ID"],
    secret=os.environ["RIPLLO_KEY_SECRET"],
)

code = ripllo.discount_codes.create({
    "code": "WELCOME10",
    "type": "percent",
    "value": 10,
    "currency": "IDR",
    "scope": "cart",
})

Go:

import ripllo "github.com/hachimi-cat/ripllo-go"

client, _ := ripllo.NewClient(ripllo.ClientOptions{
    KeyID:  os.Getenv("RIPLLO_KEY_ID"),
    Secret: os.Getenv("RIPLLO_KEY_SECRET"),
})

code, _ := client.DiscountCodes.Create(ctx, ripllo.DiscountCodeCreateInput{
    Code:     "WELCOME10",
    Type:     "percent",
    Value:    10,
    Currency: "IDR",
    Scope:    "cart",
})

The differences are idiomatic: camelCase object literals in Node, a plain dict argument in Python (the Python resources take one positional input dict, never keyword arguments), and PascalCase typed structs in Go. The underlying API call is identical.

Partner-billing mode

If you're a platform admin (the canonical example is Storlaunch) acting on behalf of downstream merchants, all three SDKs accept an onBehalfOf option that adds the X-Ripllo-On-Behalf-Of header to every request:

const ripllo = new RiplloClient({
  keyId: process.env.RIPLLO_PLATFORM_KEY_ID,
  secret: process.env.RIPLLO_PLATFORM_KEY_SECRET,
  onBehalfOf: 'acc_<storlaunchAccountId>',
});

The Node SDK also exposes client.forMerchant(accountId) which clones a fresh client scoped to that merchant — useful for per-request rescoping in a server handler:

app.use((req, res, next) => {
  req.ripllo = baseRipllo.forMerchant(req.merchant.accountId);
  next();
});

Only keys with the ripllo:platform:admin scope can use this. See API authentication for the full mechanics.

Resources covered

The Node SDK is the most readable reference for the full surface. The exposed resource groups:

discountCodes — CRUD + validate + redeem + applicable
referrals — program config, links, attribution lifecycle, rewards
abandonedCart — config, reminders, recovery, stats
pixels — merchant + public
feeds — Google Merchant Center XML
blog — CRUD + public read
broadcasts — blast sends + templates + send/test
marketingCampaigns — the campaign hub at /api/v1/marketing-campaigns: list / get / getFull / selector / create / update / delete. A distinct resource, not an alias of broadcasts — the pre-v0.5 alias was removed.
contacts / contactLists / audienceSegments — audience surface
funnels — multi-step automations
channels — provider connections (email, SMS, messaging)
inbox — engagement threads
campaigns / programs / collaborations — creator marketplace
apiKeys / webhooks / auditLog — developer surface
billing — subscription + invoices
admin — partner workspace provisioning (admin-scoped keys only)

Fourteen of those groups have a per-language deep-dive page in each of Node, Python and Go — see the Node / Python / Go SDK resources sections in the sidebar:

Discount codes · Referrals · Abandoned cart · Pixels · Feeds · Blog · Contacts · Contact lists · Audience segments · Broadcasts · Channels · API keys · Webhook endpoints · Billing

(swap node for python or go in any of those paths). For the groups without a page yet, the Node SDK source is the exact method list.

Versioning

All SDKs follow semantic versioning:

MAJOR bumps for breaking changes (rare; we'll batch them).
MINOR bumps for new features.
PATCH bumps for fixes.

Current versions are pre-1.0 (0.x). We may make small breaking changes between minor versions and document every break in the changelog.

Open-source

The SDKs live in the same repo as Ripllo itself:

Node: ripllo-node
Python: ripllo-python
Go: ripllo-go

Contributions welcome. PRs go through the same review as the rest of the codebase. Issues at github.com/hachimi-cat/ripllo-node/issues.

Installation — if you haven't installed an SDK yet.
Concepts — the data model the SDKs expose.
API reference — the underlying HTTP API.