Zeridion Flare SDKs

Zeridion Flare provides official SDKs for .NET, TypeScript/JavaScript, Python, Go, Java, PHP, and Ruby. Every SDK has two tiers: a job-management client for enqueueing, querying, cancelling, retrying, and verifying webhooks; and a worker host that runs your background jobs in-process — register, long-poll, dispatch with bounded concurrency, heartbeat with progress, honour server-side cancellation, ack the outcome, and drain on shutdown. All SDKs talk to the same REST API, so jobs enqueued from one language run on a worker in any other.

Status legend: GA = stable, semver-tracked, production-recommended · Beta = feature-complete, breaking changes possible until 1.0.

SDK	Job-management client	Worker host
.NET	GA	GA
TypeScript / JS	GA	Beta
Python	Beta	Beta (threaded; asyncio fast-follow)
Go	Beta	Beta
Java	Beta	Beta
PHP	Beta	Beta
Ruby	Beta	Beta

The Python worker host ships threaded-synchronous first (FlareWorker); an asyncio variant (AsyncFlareWorker) is a fast-follow.

Install

SDK	Package	Min runtime
.NET	`dotnet add package Zeridion.Flare`	.NET 6 / .NET Standard 2.1
TypeScript / JS	`npm install @zeridion/flare`	Node 20+ (worker) or modern browser (client)
Python	`pip install zeridion-flare`	Python 3.10+
Go	`go get github.com/zeridion/flare-go`	Go 1.22+
Java	`com.zeridion:flare` (Maven Central)	Java 17+ (LTS)
PHP	`composer require zeridion/flare`	PHP 8.2+
Ruby	`gem install zeridion-flare`	Ruby 3.2+

The worker runtime lives in the same package as the client — there is no second dependency to install. It is opt-in by import path, so client-only programs stay lean.

SDK	Worker import
.NET	`AddZeridionFlare(...)` + `IJob<T>`
TypeScript / JS	`import { FlareWorker } from "@zeridion/flare/worker"`
Python	`from zeridion_flare.worker import FlareWorker`
Go	`import "github.com/zeridion/flare-go/worker"`
Java	`com.zeridion.flare.worker.FlareWorker`
PHP	`Zeridion\Flare\Worker\FlareWorker`
Ruby	`require "zeridion_flare/worker"`

Feature parity matrix

Feature	.NET	TypeScript / JS	Python	Go	Java	PHP	Ruby
Enqueue job	✓	✓	✓	✓	✓	✓	✓
Schedule job (delay / run-at)	✓	✓	✓	✓	✓	✓	✓
Cancel job	✓	✓	✓	✓	✓	✓	✓
Retry job	✓	✓	✓	✓	✓	✓	✓
Get job status	✓	✓	✓	✓	✓	✓	✓
List jobs (filter + pagination)	✓	✓	✓	✓	✓	✓	✓
Job continuations (parent→child)	✓	✓	✓	✓	✓	✓	✓
Worker poll + ack	✓	✓	✓	✓	✓	✓	✓
Built-in worker host	✓	✓	✓	✓	✓	✓	✓
Recurring jobs	✓	✓	✓	✓	✓	✓	✓
DI / IoC integration	✓	—	—	—	—	—	—
Idempotency key	✓	✓	✓	✓	✓	✓	✓
Request-id (X-Request-Id)	✓	✓	✓	✓	✓	✓	✓
Custom tags	✓	✓	✓	✓	✓	✓	✓
Progress reporting	✓	✓	✓	✓	✓	✓	✓
Webhook signature verification	✓	✓	✓	✓	✓	✓	✓
Alerts (webhook sink)	pending	pending	pending	pending	pending	pending	pending
Outbound webhooks (CRUD + deliveries)	REST only	REST only	REST only	REST only	REST only	REST only	REST only
Audit log export	REST only	REST only	REST only	REST only	REST only	REST only	REST only
Job bulk export	REST only	REST only	REST only	REST only	REST only	REST only	REST only
Typed error hierarchy	✓	✓	✓	✓	✓	✓	✓

Legend: ✓ = available now · pending = on roadmap · — = not applicable to this SDK's model · REST only = available via direct REST call, no SDK helper yet

SDK design philosophy

Every SDK is a full background-worker framework: define a job, register it, and a built-in worker host runs it inside your process — polling for work, executing your handler with bounded concurrency, heartbeating with progress, honouring server-side cancellation, acking the outcome, and draining gracefully on shutdown. The client tier (enqueue / query / cancel / retry / verify webhooks) is always available on its own for programs that only submit work.

.NET SDK

The .NET SDK provides IJob<TPayload> / IRecurringJob interfaces, a built-in background worker that polls and executes jobs inside your process, DI/IoC registration via AddZeridionFlare, and a typed IJobClient for enqueueing. No external worker process needed.

Best for: ASP.NET Core apps and Worker Services that want zero-infra, in-process execution.

TypeScript / JavaScript SDK

The TypeScript SDK pairs a FlareClient for job management with a FlareWorker host imported from @zeridion/flare/worker. Define jobs with defineJob / defineRecurringJob, hand them to the worker, and it runs an event-loop poll/dispatch/heartbeat/drain loop with an AbortSignal-driven cancellation handle. The client stays edge-safe; the worker requires Node 20+.

Best for: Next.js backends, Node services, and any tool that needs to enqueue or run jobs.

Python SDK

The Python SDK offers the full client surface — create_job, get_job, list_jobs, cancel_job, retry_job, plus the typed error hierarchy (AuthError, QuotaError, NotFoundError, ConflictError, RateLimitError) and verify_webhook. The worker host (from zeridion_flare.worker import FlareWorker) is threaded-synchronous: register jobs with the @worker.job / @worker.recurring decorators and run a ThreadPoolExecutor-backed poll/dispatch/heartbeat loop with cooperative cancellation. An asyncio variant (AsyncFlareWorker) is a fast-follow.

Best for: data pipelines, ML inference queues, and Django/FastAPI backends.

Go SDK

The Go SDK is context.Context-native. The thin flare.Client covers every endpoint with idiomatic context-cancellation; the github.com/zeridion/flare-go/worker subpackage adds a goroutine-pool worker host. Register typed handlers with the generic worker.Handle / worker.HandleRecurring free functions and call Run(ctx) — the worker long-polls, dispatches with a bounded semaphore, heartbeats with progress, cancels via context, and drains on signal.

Best for: Go services and CLIs that enqueue or run jobs.

Java SDK

The Java SDK uses the builder pattern. FlareClient wraps every endpoint; the com.zeridion.flare.worker package adds a thread-pool worker host. Implement Job<T> / RecurringJob, annotate with @FlareJob, register on the FlareWorker.builder(), and run a fixed-pool poll/dispatch/heartbeat loop with cooperative cancellation (interrupt + flag). Ships on Java 17; an opt-in profile enables virtual threads on 21+.

Best for: Spring Boot apps and JVM services.

PHP SDK

The PHP SDK pairs Zeridion\Flare\FlareClient (PHP 8 named arguments) with a long-running CLI worker host (Zeridion\Flare\Worker\FlareWorker, bin/flare-work). Define jobs with the #[FlareJob] attribute + Job interface; the worker runs one job per process, scaled out with a process supervisor. With ext-pcntl it heartbeats a busy job in the background; without it, heartbeats flow through cooperative progress reports. A supervisor.conf.example ships with the sample.

Best for: Laravel/Symfony backends and PHP services.

Ruby SDK

The Ruby SDK pairs Zeridion::Flare::Client (keyword args) with a Sidekiq-shaped worker host (require "zeridion_flare/worker"). Mix in Zeridion::Flare::Job, declare flare_options, define perform, and a thread-pool worker drains a poll/dispatch/heartbeat loop with cooperative cancellation. Real parallelism is I/O-bound (the GVL releases on I/O); CPU-heavy work should run at lower concurrency or in external processes.

Best for: Rails apps and Ruby services.

SDK reference docs

SDK	Reference
.NET	IJob · IJobClient · IRecurringJob · JobContext · JobOptions · JobState · Exceptions · Service extensions
TypeScript / JS	FlareClient · Types · Errors · Worker
Python	Overview · Worker
Go	Overview · Worker
Java	Overview · Worker
PHP	Overview · Worker
Ruby	Overview · Worker

REST API

All SDKs wrap the same REST API. If you need a language not covered above, or want full control, use the API directly. See the API Reference and download the Postman collection.

Install​

Feature parity matrix​

SDK design philosophy​

.NET SDK​

TypeScript / JavaScript SDK​

Python SDK​

Go SDK​

Java SDK​

PHP SDK​

Ruby SDK​

SDK reference docs​

REST API​

See also​