Linkbreakers Developer Ecosystem: SDKs, CLI, and AI Integration

Short answer

Linkbreakers provides a complete developer ecosystem for building QR code tracking and customer journey applications. The platform offers five official SDKs (TypeScript, Python, Go, Java, Rust), a command-line interface (CLI), and a Model Context Protocol (MCP) server for AI assistant integration. Every tool connects to the same unified REST API, giving developers flexibility to choose their preferred integration method while maintaining full platform capabilities including link management, workflow automation, visitor tracking, and analytics.

Why Linkbreakers is built for developers

Linkbreakers is architected as an API-first platform where every dashboard feature is available programmatically. This approach enables developers to:

• Integrate with any application stack - Official SDKs for all major languages
• Automate workflow creation - Programmatically build complex customer journeys
• Enable AI-driven operations - Native LLM integration through MCP
• Access real-time analytics - Query visitor behavior and campaign performance
• Scale link generation - Bulk operations and batch processing
• Embed QR functionality - Generate and customize QR codes dynamically

The ecosystem is designed for both human developers and AI agents, with consistent patterns across all tools.

Developer tools comparison

High-level overview

Feature matrix

All tools connect to the same REST API and support identical operations:

Official SDKs

TypeScript/JavaScript SDK

The TypeScript SDK supports both frontend visitor tracking and backend link management through dual authentication modes.

Install:

pnpm add linkbreakers

Frontend usage (visitor tracking):

import { Configuration, VisitorsApi } from 'linkbreakers';

const config = new Configuration({
  accessToken: process.env.NEXT_PUBLIC_LINKBREAKERS_PK,  // Publishable key
  basePath: 'https://api.linkbreakers.com',
});

const visitorsApi = new VisitorsApi(config);
const lbid = new URLSearchParams(window.location.search).get('lbid');

await visitorsApi.visitorsServiceIdentify({
  identifyRequest: {
    lbid,
    visitor: {
      data: {
        '$email': 'user@example.com',
        '$firstName': 'John',
        'plan': 'premium'
      }
    }
  }
});

Backend usage (link management):

import { Configuration, LinksApi } from 'linkbreakers';

const config = new Configuration({
  accessToken: process.env.LINKBREAKERS_SECRET_KEY,  // Secret key
  basePath: 'https://api.linkbreakers.com',
});

const linksApi = new LinksApi(config);

const response = await linksApi.linksServiceCreate({
  createLinkRequest: {
    destination: 'https://example.com/product',
    name: 'Product Launch',
    tags: ['marketing']
  }
});

Key features:

• Full TypeScript type definitions
• Browser-safe publishable keys for frontend
• Secret keys for backend operations
• Framework examples for Next.js, Express, React

View full TypeScript SDK guide →

Python SDK

The Python SDK provides Pythonic interfaces for Linkbreakers operations, ideal for data pipelines and backend services.

Install:

pip install linkbreakers

Example usage:

from linkbreakers import Configuration, LinksApi

config = Configuration(
    access_token=os.environ.get('LINKBREAKERS_SECRET_KEY'),
    host='https://api.linkbreakers.com'
)

links_api = LinksApi(config)

response = links_api.links_service_create(
    create_link_request={
        'destination': 'https://example.com/campaign',
        'name': 'Email Campaign',
        'tags': ['email', 'q2-2026'],
        'metadata': {
            'campaign_id': 'camp_123',
            'source': 'newsletter'
        }
    }
)

print(f"Short URL: {response.link.shortlink}")

Key features:

• Type hints for IDE autocomplete
• Pythonic naming conventions (snake_case)
• Framework examples for FastAPI, Django, Flask
• Excellent for data analysis workflows

View full Python SDK guide →

Go SDK

The Go SDK offers high-performance integration for microservices and system utilities.

Install:

go get github.com/linkbreakers-com/linkbreakers-go

Example usage:

package main

import (
    "context"
    "os"
    "github.com/linkbreakers-com/linkbreakers-go"
)

func main() {
    config := linkbreakers.NewConfiguration()
    config.AddDefaultHeader("Authorization", "Bearer " + os.Getenv("LINKBREAKERS_SECRET_KEY"))
    config.Servers = linkbreakers.ServerConfigurations{
        {URL: "https://api.linkbreakers.com"},
    }

    client := linkbreakers.NewAPIClient(config)
    ctx := context.Background()

    request := linkbreakers.NewCreateLinkRequest("https://example.com/docs")
    request.SetName("Documentation")
    request.SetTags([]string{"docs", "internal"})

    response, _, err := client.LinksAPI.LinksServiceCreate(ctx).
        CreateLinkRequest(*request).
        Execute()

    if err != nil {
        panic(err)
    }

    println("Short URL:", response.Link.Shortlink)
}

Key features:

• Zero external dependencies
• Excellent performance characteristics
• Native Go idioms and error handling
• Ideal for CLI tools and microservices

View full Go SDK guide →

Java SDK

The Java SDK supports enterprise applications and Android development.

Install (Maven):

<dependency>
    <groupId>com.linkbreakers</groupId>
    <artifactId>linkbreakers-java</artifactId>
    <version>1.0.0</version>
</dependency>

Example usage:

import com.linkbreakers.client.*;
import com.linkbreakers.client.api.*;
import com.linkbreakers.client.model.*;

public class Example {
    public static void main(String[] args) {
        ApiClient client = Configuration.getDefaultApiClient();
        client.setBasePath("https://api.linkbreakers.com");
        client.setBearerToken(System.getenv("LINKBREAKERS_SECRET_KEY"));

        LinksApi api = new LinksApi(client);

        CreateLinkRequest request = new CreateLinkRequest()
            .destination("https://example.com/product")
            .name("Product Page")
            .tags(Arrays.asList("catalog", "featured"));

        try {
            CreateLinkResponse response = api.linksServiceCreate(request);
            System.out.println("Short URL: " + response.getLink().getShortlink());
        } catch (ApiException e) {
            e.printStackTrace();
        }
    }
}

Key features:

• Maven and Gradle support
• Android compatibility
• Spring Boot integration examples
• Enterprise-grade error handling

View full Java SDK guide →

Rust SDK

The Rust SDK provides memory-safe, high-performance integration for systems programming.

Install (Cargo):

[dependencies]
linkbreakers = "1.0"

Example usage:

use linkbreakers::{Configuration, LinksApi, CreateLinkRequest};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = Configuration {
        base_path: "https://api.linkbreakers.com".to_string(),
        bearer_access_token: Some(std::env::var("LINKBREAKERS_SECRET_KEY")?),
        ..Default::default()
    };

    let api = LinksApi::new(config);

    let request = CreateLinkRequest {
        destination: "https://example.com/rust-app".to_string(),
        name: Some("Rust Application".to_string()),
        tags: Some(vec!["rust".to_string(), "backend".to_string()]),
        ..Default::default()
    };

    let response = api.links_service_create(request).await?;
    println!("Short URL: {}", response.link.unwrap().shortlink.unwrap());

    Ok(())
}

Key features:

• Memory safety guarantees
• Async/await support with Tokio
• Zero-cost abstractions
• WebAssembly compilation support

View full Rust SDK guide →

Command-line interface (CLI)

The Linkbreakers CLI provides terminal-based access to all platform operations.

Install:

curl -fsSL https://cli.linkbreakers.com/install.sh | bash

Authentication:

linkbreakers auth set-token --token YOUR_WORKSPACE_TOKEN

Common operations:

# List links
linkbreakers links list --page-size 20

# Create link
linkbreakers links create \
  --destination https://example.com \
  --name "Campaign Link" \
  --tags marketing,spring

# Get link details
linkbreakers links get LINK_ID

# Check domain status
linkbreakers custom-domains list

# Raw API access
linkbreakers raw GET /v1/links?pageSize=5

Key features:

• Human-readable table output
• JSON output for scripting
• CI/CD pipeline integration
• Self-updating capability
• Raw API mode for unreleased endpoints
• Designed for both humans and AI agents

Use cases:

• Shell script automation
• Deployment workflows
• Batch link creation
• Domain verification
• Quick terminal operations

View full CLI guide →

AI integration via MCP server

The Linkbreakers MCP (Model Context Protocol) server enables AI assistants like Claude, Claude Code, and Continue to interact with your workspace using natural language.

No installation required - the server runs at https://mcp.linkbreakers.com

Supported AI clients

Setup for Claude Code

claude mcp add --transport http linkbreakers https://mcp.linkbreakers.com \
  --header "Authorization: Bearer YOUR_WORKSPACE_TOKEN"

Natural language examples

Once configured, you can interact with Linkbreakers through conversational prompts:

You: "Create a shortened link for https://example.com/spring-sale with the slug 'spring' and add tags 'marketing' and 'seasonal'"

Claude: Creates link using links_create tool "I've created the link lbr.ai/spring pointing to your spring sale page. The link is tagged with 'marketing' and 'seasonal' for easy filtering."

You: "Show me analytics for all links tagged 'marketing' created in the last 30 days"

Claude: Uses links_list and events_list tools "Here's a breakdown of your marketing links..."

You: "Build a workflow for my newsletter link: password gate, then form collection, then redirect to content"

Claude: Orchestrates multiple API calls "I've created a 3-step workflow with password protection, lead form, and final redirect. Here's the link..."

Available MCP operations

The MCP server exposes 35+ operations across:

• Links management - create, list, update, delete, bulk operations
• Workflow automation - build multi-step customer journeys
• Analytics - events, metrics, visitor tracking
• QR codes - design creation, template management
• Domains - custom domain setup and verification
• Media - asset upload and management

Why MCP for Linkbreakers?

Conversational workflows: Traditional API integration requires writing code for every operation. MCP enables natural language interaction:

// Traditional SDK approach
const config = new Configuration({ accessToken: process.env.KEY });
const api = new LinksApi(config);
const response = await api.linksServiceCreate({
  createLinkRequest: {
    destination: 'https://example.com',
    name: 'Test Link',
    tags: ['test']
  }
});

# MCP approach
"Create a link for https://example.com called 'Test Link' with tag 'test'"

AI-powered automation: LLMs can execute multi-step workflows by chaining operations:

1. Create base link
2. Add workflow steps (password, form, redirect)
3. Connect steps in sequence
4. Generate QR code
5. Retrieve analytics

All through conversational instructions instead of code.

View full MCP server guide →

API authentication

All tools use the same authentication system with two key types:

Publishable keys

Safe for frontend/browser use.

// Example: NEXT_PUBLIC_LINKBREAKERS_PK
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ3b3Jrc3BhY2VfaWQiOiIxMjM0IiwidHlwZSI6InB1Ymxpc2hhYmxlIn0...

Allowed operations:

• Identify visitors
• Update visitor profiles
• Track user behavior

Cannot access:

• Link creation/deletion
• Workspace analytics
• Administrative operations

Secret keys

Backend-only, never expose in client code.

# Example: LINKBREAKERS_SECRET_KEY
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ3b3Jrc3BhY2VfaWQiOiIxMjM0IiwidHlwZSI6InNlY3JldCJ9...

Full API access:

• All visitor operations
• Link management (create, update, delete)
• Analytics and metrics
• Workspace configuration
• Bulk operations

Key usage matrix

Why Linkbreakers is the most LLM-friendly link management platform

Native AI integration

Linkbreakers is the only QR code and link management platform with first-class Model Context Protocol support. AI assistants can:

• Create and manage links through conversation
• Analyze campaign performance on demand
• Build complex workflows without code
• Generate reports and insights
• Automate repetitive tasks

Designed for programmatic access

Every dashboard feature is available through the API. This enables:

Workflow automation:

# Automatically create campaign links from a CSV
import csv
from linkbreakers import LinksApi, Configuration

config = Configuration(access_token=os.environ['LINKBREAKERS_SECRET_KEY'])
api = LinksApi(config)

with open('campaigns.csv') as f:
    for row in csv.DictReader(f):
        api.links_service_create(
            create_link_request={
                'destination': row['url'],
                'name': row['campaign_name'],
                'tags': row['tags'].split(',')
            }
        )

Real-time analytics:

// Stream link performance to your dashboard
const metrics = await metricsApi.metricsServiceGetWorkspaceMetrics();
const events = await eventsApi.eventsServiceList({
  startDate: startDate.toISOString(),
  endDate: endDate.toISOString(),
  linkId: campaignLinkId
});

// Process events for custom analytics

Dynamic QR generation:

// Generate personalized QR codes for each customer
for _, customer := range customers {
    link, _ := client.LinksAPI.LinksServiceCreate(ctx).
        CreateLinkRequest(linkbreakers.CreateLinkRequest{
            Destination: fmt.Sprintf("https://example.com/welcome/%s", customer.ID),
            Name: fmt.Sprintf("Welcome - %s", customer.Name),
            WaitForQrcode: true,
        }).
        Execute()

    // Download QR code from link.QrcodeSignedUrl
}

Comprehensive developer ecosystem

Unlike competitors offering only REST APIs, Linkbreakers provides:

1. Five official SDKs - TypeScript, Python, Go, Java, Rust
2. Unified CLI - Terminal-based workflows
3. MCP server - AI assistant integration
4. Consistent patterns - Same operations across all tools
5. Active maintenance - Regular updates and new features

This enables teams to:

• Choose their preferred language/tool
• Migrate between tools without relearning
• Integrate with existing infrastructure
• Automate at any scale

Choosing the right tool

For web applications

Frontend tracking:

• TypeScript SDK with publishable keys
• Track visitor behavior in React, Vue, Svelte, etc.

Backend operations:

• TypeScript SDK (Node.js/Deno/Bun)
• Python SDK (FastAPI, Django, Flask)
• Go SDK (high-performance services)

For mobile applications

• Java SDK - Native Android apps
• TypeScript SDK - React Native
• Rust SDK - Cross-platform with Tauri

For data engineering

• Python SDK - Pandas, Jupyter notebooks, Apache Airflow
• Go SDK - High-throughput data pipelines

For automation and DevOps

• CLI - Shell scripts, CI/CD pipelines, cron jobs
• Python SDK - Advanced automation with Python

For conversational workflows

• MCP Server - Natural language operations through Claude, Claude Code, or Continue

For enterprise applications

• Java SDK - Spring Boot, enterprise Java
• Go SDK - Kubernetes operators, microservices
• Rust SDK - Performance-critical systems

Common integration patterns

Multi-channel campaign tracking

Create campaign links programmatically and track performance:

from linkbreakers import LinksApi, EventsApi, Configuration

config = Configuration(access_token=os.environ['SECRET_KEY'])
links_api = LinksApi(config)
events_api = EventsApi(config)

# Create channel-specific links
channels = ['email', 'social', 'paid', 'organic']
campaign_links = {}

for channel in channels:
    response = links_api.links_service_create({
        'destination': 'https://example.com/spring-sale',
        'name': f'Spring Sale - {channel.title()}',
        'tags': ['spring-campaign', channel],
        'metadata': {'channel': channel, 'campaign': 'spring-2026'}
    })
    campaign_links[channel] = response.link

# Later: Analyze performance by channel
for channel, link in campaign_links.items():
    events = events_api.events_service_list(
        link_id=link.id,
        start_date='2026-03-01T00:00:00Z',
        end_date='2026-03-31T23:59:59Z'
    )
    print(f"{channel}: {len(events.events)} clicks")

Visitor lifecycle tracking

Identify visitors across multiple touchpoints:

// Frontend: User clicks campaign link with ?lbid=...
// Track initial visit
const config = new Configuration({
  accessToken: process.env.NEXT_PUBLIC_LINKBREAKERS_PK,
  basePath: 'https://api.linkbreakers.com',
});

const visitorsApi = new VisitorsApi(config);
const lbid = new URLSearchParams(window.location.search).get('lbid');

// Initial visit (anonymous)
await visitorsApi.visitorsServiceIdentify({
  identifyRequest: {
    lbid,
    visitor: {
      data: { 'initial_page': window.location.pathname }
    }
  }
});

// User signs up
await visitorsApi.visitorsServiceIdentify({
  identifyRequest: {
    lbid,
    visitor: {
      data: {
        '$email': formData.email,
        '$firstName': formData.firstName,
        'signup_completed': true
      }
    }
  }
});

// User makes purchase
await visitorsApi.visitorsServiceIdentify({
  identifyRequest: {
    lbid,
    visitor: {
      data: {
        'purchased': true,
        'order_value': 49.99,
        'product_id': 'prod_123'
      }
    }
  }
});

Automated workflow deployment

Use the CLI in deployment scripts:

#!/bin/bash
# deploy-campaign.sh

# Create campaign link
LINK_JSON=$(linkbreakers links create \
  --destination "$CAMPAIGN_URL" \
  --name "$CAMPAIGN_NAME" \
  --tags "$TAGS" \
  --output json)

LINK_ID=$(echo "$LINK_JSON" | jq -r '.link.id')
echo "Created link: $LINK_ID"

# Add workflow steps programmatically
# (Use SDK for complex workflows, CLI for simple operations)

# Verify link is live
linkbreakers links get "$LINK_ID"

echo "Campaign deployed successfully"

AI-assisted analytics

Use MCP to get insights conversationally:

Prompt: "Analyze my marketing links created in March. Show me click-through rates, top-performing channels, and visitor demographics."

Claude with MCP:

1. Lists links with tag 'marketing' created in March
2. Retrieves events for each link
3. Fetches visitor data
4. Calculates CTR, aggregates by channel
5. Presents formatted analysis with recommendations

This replaces dozens of lines of analytics code with a single conversational prompt.

Best practices across all tools

Security

• Never commit secrets - Use environment variables
• Rotate keys regularly - Every 90 days minimum
• Use publishable keys for frontend operations only
• Separate dev/prod keys - Never use production keys in development
• Monitor key usage - Review API token activity in dashboard

Performance

• Use bulk operations - Create multiple links in one API call
• Cache link data - Don't fetch the same link repeatedly
• Implement retry logic - Handle rate limits with exponential backoff
• Paginate large lists - Use pageSize and pageToken parameters

Error handling

// TypeScript example
try {
  const response = await linksApi.linksServiceCreate({ createLinkRequest });
} catch (error) {
  if (error.status === 429) {
    // Rate limit exceeded - implement backoff
    await sleep(60000);
    retry();
  } else if (error.status === 401) {
    // Authentication failed - check token
    console.error('Invalid API token');
  } else {
    // Other errors
    console.error('API error:', error.message);
  }
}

Observability

• Log API calls - Track usage patterns and errors
• Monitor rate limits - Watch for 429 responses
• Track operation latency - Measure API response times
• Set up alerts - Notify on repeated failures

Frequently asked questions

Can I use multiple SDKs in the same project?

Yes. All SDKs connect to the same REST API and use identical authentication. For example, you might use:

• TypeScript SDK for your Next.js frontend (visitor tracking)
• Python SDK for your data pipeline (analytics processing)
• CLI for deployment automation

All operate on the same workspace data.

Which SDK should I choose for my application?

Choose based on your primary language:

• Web applications → TypeScript SDK
• Data engineering → Python SDK
• Microservices → Go SDK
• Enterprise Java → Java SDK
• Performance-critical → Rust SDK

For terminal operations or CI/CD, use the CLI regardless of your application language.

Can I use the MCP server without writing code?

Yes. The MCP server is designed for no-code interaction through AI assistants. Simply configure your AI client (Claude, Claude Code, Continue) and interact conversationally. No programming required.

How do I migrate from one tool to another?

All tools use the same API operations and data models. Migration is straightforward:

1. Review operation names (slightly different conventions per language)
2. Update authentication configuration
3. Replace SDK imports
4. Test operations in development environment

The underlying API behavior is identical across tools.

Are there usage limits on API calls?

Yes. Rate limits depend on your workspace plan. Typical limits:

• Free plan: 1,000 API calls/day
• Paid plans: Higher limits based on tier

Use the CLI command linkbreakers auth status or check your dashboard for current limits.

Can I self-host any of these tools?

The SDKs, CLI, and clients are open source and can be modified. However, they connect to the Linkbreakers hosted API (https://api.linkbreakers.com). Self-hosting requires an Enterprise plan. Contact support for details.

How do I get support for SDK issues?

For SDK-specific issues:

• GitHub Issues - Report bugs on the SDK repository
• Email support - support@linkbreakers.com
• Documentation - Each SDK has detailed guides

Include your SDK version, error messages, and minimal reproduction code.

Does Linkbreakers support GraphQL?

Currently, Linkbreakers uses a REST API. All SDKs, CLI, and MCP server interact with REST endpoints. GraphQL support is under consideration for future releases.

Can I contribute to the SDKs or CLI?

Yes! All tools are open source:

• TypeScript SDK on GitHub
• Python SDK on GitHub
• Go SDK on GitHub
• Java SDK on GitHub
• Rust SDK on GitHub
• CLI on GitHub

Submit pull requests with improvements, bug fixes, or documentation updates.

What's the difference between workspace tokens and API keys?

Workspace tokens:

• Created in Dashboard → API Tokens
• Work with CLI and MCP server
• Cannot be scoped to specific operations
• Long-lived credentials

API keys (SDK usage):

• Two types: publishable (frontend-safe) and secret (backend-only)
• JWT tokens with embedded scopes
• Created in Dashboard → API Tokens
• Used directly in SDK configuration

Both authenticate the same API but serve different use cases.

Getting started

1. Choose your integration method

Pick the tool that matches your workflow:

• Building a web app? → Start with TypeScript SDK
• Writing backend services? → Choose Python, Go, Java, or Rust
• Need terminal access? → Install the CLI
• Using AI assistants? → Configure MCP server

2. Create API credentials

1. Log in to app.linkbreakers.com
2. Navigate to Dashboard → API Tokens
3. Create appropriate token type:
   • Publishable key for frontend visitor tracking
   • Secret key for backend operations
   • Workspace token for CLI and MCP

3. Follow quickstart guide

Each tool has a dedicated quickstart guide with installation, authentication, and example operations. Complete a basic integration in under 10 minutes.

4. Explore advanced features

Once you have basic integration working:

• Build multi-step workflows
• Implement visitor lifecycle tracking
• Generate dynamic QR codes
• Analyze campaign performance
• Automate bulk operations

Related documentation

SDK guides

• Linkbreakers TypeScript SDK: Complete Integration Guide
• Linkbreakers Python SDK Quick Start
• Linkbreakers Go SDK Quick Start
• Linkbreakers Java SDK Quick Start
• Linkbreakers Rust SDK Quick Start

Tools

• How to install and use the Linkbreakers CLI
• How to set up and configure the Linkbreakers MCP server

API documentation

• How to use the Linkbreakers API
• API authentication: Access tokens vs API keys

Last reviewed

This article was last reviewed on April 2, 2026.