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
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.
Typed request/response objects. Works in Node.js, Cloudflare Workers, Vercel Edge, and Deno.
npm install @elido/sdkIdiomatic Go with context propagation and zero-allocation hot paths for high-throughput services.
go get github.com/elidoapp/elido-goSync and async (asyncio) clients. Typed with Pydantic v2 models. Available on PyPI.
pip install elido-sdkModel Context Protocol server — connect Elido link management to Claude, ChatGPT, Cursor, and any MCP-compatible AI agent.
npx @elido/mcp-serverAPI 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 referenceAuthenticated calls from the browser
- Postman collectionAuto-generated from the OpenAPI spec
- SDK generationTypes built from spec on every release
- 90-day deprecationBreaking changes flagged well in advance
- POST
/v1/linksCreate a short link - GET
/v1/links/{id}Retrieve a link by ID - PATCH
/v1/links/{id}Update link destination or metadata - DELETE
/v1/links/{id}Archive or delete a link - GET
/v1/linksList links (cursor-paginated) - POST
/v1/bulk/linksBulk-create up to 500 links
X-RateLimit-Remaining
X-RateLimit-Reset
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.
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.
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.
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.
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 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.”
“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.”
“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.”
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.
| Feature | Elido | Bitly API | Rebrandly API |
|---|---|---|---|
| OpenAPI / Swagger spec | OpenAPI 3.1 — downloadable, source of truth for SDKs | Swagger spec available | OpenAPI spec available |
| Official SDKs | TypeScript, Go, Python — generated from spec | JavaScript and Python official SDKs | JavaScript SDK only |
| Rate limit (Business) | 1,000 requests/min with burst | Enterprise plan: varies by contract | 500 requests/min (Business) |
| MCP server for AI agents | Yes — @elido/mcp-server on npm | Not available | Not available |
| Per-scope API key permissions | Yes — 9 scopes, per-key assignment | Read-only vs read-write only | Limited scope control |
| Webhook delivery | HMAC-SHA256 signed, auto-retry, SIEM mode | Not available | Not available |
| gRPC internal API | Yes — edge to core, low-latency internal calls | REST only | REST 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.
Keep reading
HMAC-signed outbound event delivery — the async complement to the synchronous API.
The API resource you'll call most — create, update, and query short links programmatically.
Query click events and aggregates via the analytics API — same data as the ClickHouse dashboard.
The developer-oriented solution page — REST, SDKs, webhooks, and the developer experience overview.