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.
- Official SDKs for TypeScript, Go, Python, and Ruby
- 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.
Idiomatic Go with context propagation and zero-allocation hot paths for high-throughput services.
Sync and async (asyncio) clients. Typed with Pydantic v2 models.
Model Context Protocol server - connect Elido link management to Claude, ChatGPT, Cursor, and any MCP-compatible AI agent.
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 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 official TypeScript SDK 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 is idiomatic Go with context propagation and zero-allocation hot paths for high-throughput use. The Python SDK includes both sync and async (asyncio) clients. The Ruby SDK ships idiomatic Ruby with sync HTTP and ActiveRecord-friendly error types. All four SDKs are generated from the same OpenAPI spec using a custom generator - updates ship the same day as the API release. The SDKs are not published publicly yet: public release coming soon; contact support for early access. 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 official Elido MCP server 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 not published publicly yet: public release coming soon; contact support for early access.
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 high-volume integration calling Elido's API), contact sales for a custom limit.
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.
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. All configurations require a valid Elido API key with the relevant scopes. The MCP server is not published publicly yet: public release coming soon; contact support for early access.
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 analytics dashboard.
The developer-oriented solution page - REST, SDKs, webhooks, and the developer experience overview.