Elido
Everything Elido does
All plans (rate limits vary)

API & SDKs. Build on Elido, in any language.

Full REST API, TypeScript, Go, and Python SDKs, plus an MCP server for AI agent workflows. Rate limits scale with plan; API keys are workspace-scoped with granular permission sets.

  • TypeScript, Go, and Python SDKs — all open-source
  • OpenAPI 3.1 spec with interactive docs
  • MCP server for Claude and AI agent workflows
  • Per-scope API keys with plan-based rate limits
TypeScriptGoPython
import{Elido}from'@elido/sdk'
constelido=newElido('sk_live_…')
constlink=awaitelido.links.create({
url:'https://acme.com/q2-launch',
domain:'go.acme.com',
slug:'q2',
}))
Response
{
"id": "lnk_01hx…",
"short_url": "https://go.acme.com/q2",
"domain": "go.acme.com"
}
TypeScript SDK — @elido/sdkv1.x · npm
3
Official SDKs (TS, Go, Python)
OpenAPI 3.1
Machine-readable API spec
1,000 req/min
Rate limit on Business
MCP
AI agent protocol support

Official SDKs

Four SDKs. One API surface.

Every SDK is generated from the same OpenAPI 3.1 spec — when the API ships, the SDKs update the same day. TypeScript types, Go interfaces, and Python dataclasses stay in sync automatically.

TypeScript
v1.x
@elido/sdk

Typed request/response objects. Works in Node.js, Cloudflare Workers, Vercel Edge, and Deno.

$npm install @elido/sdk
npm
Go
v1.x
github.com/elidoapp/elido-go

Idiomatic Go with context propagation and zero-allocation hot paths for high-throughput services.

$go get github.com/elidoapp/elido-go
go get
Python
v1.x
elido-sdk

Sync and async (asyncio) clients. Typed with Pydantic v2 models. Available on PyPI.

$pip install elido-sdk
pip
MCP Server
v1.x
@elido/mcp-server

Model Context Protocol server — connect Elido link management to Claude, ChatGPT, Cursor, and any MCP-compatible AI agent.

$npx @elido/mcp-server
npx

API reference

OpenAPI 3.1. Interactive. Always current.

The OpenAPI spec at /openapi.json is the source of truth for every endpoint, parameter, and response shape. SDK types are generated from it — no drift, no hand-maintained stubs.

  • Downloadable spec
    /openapi.json — machine-readable JSON
  • Interactive reference
    Authenticated calls from the browser
  • Postman collection
    Auto-generated from the OpenAPI spec
  • SDK generation
    Types built from spec on every release
  • 90-day deprecation
    Breaking changes flagged well in advance
API Reference
OpenAPI 3.1
v1
Search endpoints…
Links
  • POST/v1/links
  • GET/v1/links/{id}
  • PATCH/v1/links/{id}
  • DELETE/v1/links/{id}
  • GET/v1/links
  • POST/v1/bulk/links
6 of 34 endpoints shownLive spec · /openapi.json
Rate limits by plan
Per-scope API keys
Free
100 req/min
Burst: 1,000 req burst (10x, 5s window)1%
Pro
1,000 req/min
Burst: 10,000 req burst (10x, 5s window)10%
Business
10,000 req/min
Burst: 100,000 req burst (10x, 5s window)100%
Algorithm
Token bucket
Headers
X-RateLimit-Limit
X-RateLimit-Remaining
X-RateLimit-Reset
Per-scope keys: analytics:read keys don't burn your links:write quota — each scope has an independent bucket.

Rate limits

Limits that scale with your plan.

Token-bucket rate limiting per workspace per API key. Burst allowances let you spike 10x for up to 5 seconds — so a batch link-creation job at the start of a campaign never hits the wall.

  • X-RateLimit-Limit / Remaining / Reset headers on every response
  • SDK auto-retries with exponential backoff on 429
  • Bulk endpoints have separate, higher limits
  • Per-scope keys — analytics read-only keys don't burn write quota
  • Custom limits for high-volume enterprise workloads — contact sales

What you can do

  • REST API with OpenAPI 3.1 spec
  • TypeScript, Go, and Python SDKs
  • MCP server for Claude, ChatGPT, Cursor
  • Workspace-scoped API keys with per-scope permissions
  • Webhooks for async event delivery
  • gRPC internal API (edge → core)

What the Elido API stack gives developers

An OpenAPI spec and some SDKs are the floor. The capabilities below cover the details that matter when building production integrations.

REST API
01

OpenAPI 3.1 spec, Postman collection, and interactive reference — every endpoint documented with examples

Every Elido API endpoint is documented in the OpenAPI 3.1 spec, available at /docs/api-reference and as a downloadable JSON file at /openapi.json. The spec is the source of truth — SDK types are generated from it, so there's no drift between the reference and the SDK. The interactive API reference lets you make authenticated calls against your workspace directly from the browser (paste your API key, pick the workspace, call the endpoint). A Postman collection is auto-generated from the OpenAPI spec and linked from each endpoint's documentation page. Changelog for the API is versioned alongside the main changelog — breaking changes get a 90-day deprecation notice with a migration guide before removal.

SDK coverage
02

TypeScript, Go, and Python SDKs — generated from the OpenAPI spec, updated on each API release

The TypeScript SDK (@elido/sdk) is published to npm and covers the full API surface with typed request and response objects. It supports both Node.js and edge runtimes (Cloudflare Workers, Vercel Edge, Deno). The Go SDK (github.com/elidoapp/elido-go) is idiomatic Go with context propagation and zero-allocation hot paths for high-throughput use. The Python SDK (elido-python, available on PyPI) includes both sync and async (asyncio) clients. All three SDKs are generated from the same OpenAPI spec using a custom generator — updates ship the same day as the API release. Community-maintained SDKs for Ruby and PHP exist; they're listed in the docs but not officially supported. If your language isn't covered, the OpenAPI spec is the fastest path to building a client.

Authentication
03

Workspace API keys with per-scope permissions — separate keys for read-only analytics vs link management vs admin

API keys are workspace-scoped (not user-scoped) and include a permission set defined at key creation time. Scopes: links:read, links:write, links:delete, analytics:read, campaigns:read, campaigns:write, webhooks:manage, domains:manage, workspace:admin. Read-only analytics integrations should use a key with only analytics:read. CI/CD pipelines that create links should use links:write. Admin operations require workspace:admin. Keys can be rotated individually without revoking other keys — rotation generates a new key value, the old value is invalidated immediately. Keys are shown only once at creation; Elido stores an HMAC of the key, not the plaintext. For SCIM-provisioned teams, service account keys are recommended over personal API keys for production integrations.

MCP server
04

Elido MCP server: connect link management to Claude, ChatGPT, Cursor, and any MCP-compatible AI agent

The Elido MCP server (@elido/mcp-server, published to npm) implements the Model Context Protocol and exposes Elido link management as tools callable by AI agents. Supported tools: create_link, get_link, update_link, list_links, get_analytics, create_campaign, list_campaigns. The MCP server authenticates with a workspace API key and scopes tool access to the key's permissions. Wire it into Claude's tool-use loop, the ChatGPT Plugins (function calling), Cursor's AI context, or any MCP-compatible runtime. Use case example: an AI assistant that takes a natural-language brief ('create five links for this product launch, one per channel, with UTMs from the Q2-launch campaign template') and calls create_link five times with the right parameters derived from the brief. The MCP server is self-hostable or runs as an npx binary for local development.

Rate limits and quotas
05

Rate limits by plan — Free 60/min, Pro 300/min, Business 1,000/min — plus burst allowances

API rate limits apply per workspace per API key: Free 60 requests/minute, Pro 300/minute, Business 1,000/minute. Burst allowances let you exceed the limit for up to 5 seconds (10x the rate limit) before hard limiting kicks in. Rate limit headers are included in every response: X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset (Unix timestamp). The SDKs include automatic retry with exponential backoff on 429 responses — you don't need to implement this yourself. For bulk operations (link creation, analytics export), prefer the bulk endpoints (POST /bulk, scheduled exports) over per-item API calls — bulk endpoints have separate, higher limits. If your use case requires sustained throughput above Business limits (e.g., a self-hosted high-volume redirector calling Elido's API for cache population), contact sales for a custom limit.

Developer teams building on the Elido API

Names are placeholders — real customer case studies land here as they are published.

The TypeScript SDK types are generated from the OpenAPI spec — when Elido ships a new API version, we update the package version and TypeScript tells us immediately if our integration uses a deprecated field. No surprise runtime errors.

E
Engineering team, e-commerce platform, Lisbon
Lead Backend Engineer

We wired the Elido MCP server into Claude to let our content team create and tag campaign links from a chat interface. Setup was 20 minutes. The content team now creates 40% fewer support tickets to engineering for link management tasks.

A
AI integrations team, marketing agency, Berlin
VP Engineering

The Go SDK with context propagation fits directly into our service mesh. We create short links for shipment tracking pages server-side, at the point of shipment creation — the SDK handles retries and rate limit backoff transparently.

P
Platform team, logistics SaaS, Warsaw
Senior Platform Engineer

Elido API & SDKs vs Bitly API vs Rebrandly API

All three have REST APIs. The differences are in SDK quality, rate limits, OpenAPI spec availability, and MCP/AI agent support.

FeatureElidoBitly APIRebrandly API
OpenAPI / Swagger specOpenAPI 3.1 — downloadable, source of truth for SDKsSwagger spec availableOpenAPI spec available
Official SDKsTypeScript, Go, Python — generated from specJavaScript and Python official SDKsJavaScript SDK only
Rate limit (Business)1,000 requests/min with burstEnterprise plan: varies by contract500 requests/min (Business)
MCP server for AI agentsYes — @elido/mcp-server on npmNot availableNot available
Per-scope API key permissionsYes — 9 scopes, per-key assignmentRead-only vs read-write onlyLimited scope control
Webhook deliveryHMAC-SHA256 signed, auto-retry, SIEM modeNot availableNot available
gRPC internal APIYes — edge to core, low-latency internal callsREST onlyREST only

API & SDK questions

Is the API versioned? How do breaking changes work?

Yes. The current version is v1, accessed at /v1/... Breaking changes are announced in the changelog with a 90-day deprecation window before the old behavior is removed. Non-breaking additions (new fields, new optional parameters) ship without a version bump. The API version is stable; if v2 is ever introduced, v1 will run in parallel for at least 12 months. The OpenAPI spec at /openapi.json always reflects the current stable version.

What authentication method does the API use?

Bearer token authentication: include your API key in the Authorization header as 'Bearer elido_sk_...'. The key value is shown once at creation. For server-to-server webhook calls from Elido to your system, Elido signs the request body with HMAC-SHA256 using a shared secret — verify the X-Elido-Signature header on your webhook handler. OAuth2 client credentials are available for partner integrations where workspace API key distribution is impractical — contact us for OAuth2 partner onboarding.

Does the TypeScript SDK work in Cloudflare Workers and edge runtimes?

Yes. The TypeScript SDK uses the fetch API (available in all modern edge runtimes) and avoids Node.js-only APIs (no fs, no http, no Buffer). It's tested on Cloudflare Workers, Vercel Edge Functions, and Deno Deploy. If you're running the SDK in a constrained edge environment, use the lightweight import path (@elido/sdk/edge) which excludes the CLI utilities and Node.js-only modules from the bundle.

How do I use the MCP server with Claude or ChatGPT?

For Claude: add the MCP server to your claude_desktop_config.json with your API key as an environment variable — the Elido MCP docs have a one-block copy-paste config. For ChatGPT (function calling): the MCP server exposes a JSON Schema tool manifest at /.well-known/mcp.json that you can import into your GPT's action configuration. For Cursor: add the MCP server as a local tool in Cursor's settings with npx @elido/mcp-server. All configurations require a valid Elido API key with the relevant scopes.

What's the pagination model for list endpoints?

All list endpoints use cursor-based pagination. Response includes a next_cursor field (null if no more pages). Pass the cursor value as the cursor query parameter on the next request. Default page size is 50; maximum is 200. Cursor-based pagination is stable — adding or deleting records between pages doesn't cause items to be skipped or repeated, unlike offset-based pagination. The SDKs include an auto-paginate helper that yields items one at a time regardless of page boundaries.

Can I use the API to manage multiple workspaces from a single client?

Yes. API keys are workspace-scoped, but you can hold keys for multiple workspaces. The API endpoint prefix is /v1/workspaces/{workspace_id}/... — pass the workspace ID of the target workspace. If you're building a multi-workspace management tool (e.g., an agency portal managing client workspaces), you'll hold one API key per workspace. OAuth2 partner credentials with cross-workspace scope are available for platform integrations — contact sales.

What's the rate limit on the free plan and how is it enforced?

Free plan: 60 requests per minute per workspace. Rate limit is enforced at the API gateway with a token bucket algorithm. When the bucket is empty, the API returns HTTP 429 with a Retry-After header indicating when the next token is available. The SDKs automatically respect Retry-After on 429 responses. Note that bulk endpoints have separate limits — the link bulk-create endpoint counts as one request regardless of how many links are in the payload.

Is there a sandbox or test environment?

Yes — pass the X-Elido-Sandbox: true header to any API request to run it against the sandbox environment. Sandbox requests create real objects in a sandboxed workspace partition (links, campaigns, etc.) but redirect traffic is not served from the production edge. Use the sandbox for integration testing and CI/CD pipelines. Sandbox objects do not count against your plan's link or click quotas. The sandbox resets every 24 hours — do not depend on sandbox data for production use.

Ready to try it?

Start on the free plan, upgrade when you need a custom domain.

API & SDKs — Build on Elido, in any language. · Elido