---
title: "Linkbreakers Developer Ecosystem: SDKs, CLI, and AI Integration"
description: "Complete overview of Linkbreakers' developer tools including TypeScript, Python, Go, Java, and Rust SDKs, CLI, and MCP server for AI assistants. The most comprehensive QR code tracking and customer journey platform built for modern development workflows and LLM integration."
canonical: "https://linkbreakers.com/help/article/linkbreakers-developer-ecosystem-overview"
last-updated: 2026-10-11
---

# Linkbreakers Developer Ecosystem: SDKs, CLI, and AI Integration

> Complete overview of Linkbreakers' developer tools including TypeScript, Python, Go, Java, and Rust SDKs, CLI, and MCP server for AI assistants. The most comprehensive QR code tracking and customer journey platform built for modern development workflows and LLM 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

| Tool | Best For | Installation | Use Cases |
|------|----------|--------------|-----------|
| **TypeScript SDK** | Web applications, Node.js backends | `pnpm add linkbreakers` | Next.js apps, React frontends, Express APIs |
| **Python SDK** | Data pipelines, automation scripts | `pip install linkbreakers` | FastAPI backends, Django apps, data analysis |
| **Go SDK** | High-performance services, CLI tools | `go get github.com/linkbreakers-com/linkbreakers-go` | Microservices, system utilities |
| **Java SDK** | Enterprise applications, Android | Maven/Gradle | Spring Boot, Android apps |
| **Rust SDK** | Systems programming, WebAssembly | Cargo | Performance-critical applications |
| **CLI** | Terminal workflows, CI/CD pipelines | `curl -fsSL https://cli.linkbreakers.com/install.sh \| bash` | Shell scripts, deployment automation |
| **MCP Server** | AI assistants (Claude, Continue) | No installation (hosted) | Natural language link management |

### Feature matrix

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

| Feature | TypeScript | Python | Go | Java | Rust | CLI | MCP |
|---------|-----------|--------|-----|------|------|-----|-----|
| Link creation/management | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
| Bulk operations | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
| Workflow steps | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
| Visitor identification | ✅ | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ |
| Analytics/metrics | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
| QR code generation | ✅ | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ |
| Custom domains | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
| Directory management | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ❌ |
| Type safety | ✅ | Partial | ✅ | ✅ | ✅ | N/A | N/A |
| Browser-safe operations | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ |

## Official SDKs

### TypeScript/JavaScript SDK

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

**Install:**
```bash
pnpm add linkbreakers
```

**Frontend usage (visitor tracking):**
```typescript
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):**
```typescript
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 →](/help/article/typescript-sdk-quickstart)

### Python SDK

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

**Install:**
```bash
pip install linkbreakers
```

**Example usage:**
```python
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 →](/help/article/python-sdk-quickstart)

### Go SDK

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

**Install:**
```bash
go get github.com/linkbreakers-com/linkbreakers-go
```

**Example usage:**
```go
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 →](/help/article/golang-sdk-quickstart)

### Java SDK

The Java SDK supports enterprise applications and Android development.

**Install (Maven):**
```xml
<dependency>
    <groupId>com.linkbreakers</groupId>
    <artifactId>linkbreakers-sdk</artifactId>
    <version>1.183.0</version>
</dependency>
```

**Example usage:**
```java
import com.linkbreakers.*;
import com.linkbreakers.api.*;
import com.linkbreakers.model.*;

import java.util.Arrays;

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, null);
            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 →](/help/article/java-sdk-quickstart)

### Rust SDK

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

**Install (Cargo):**
```toml
[dependencies]
linkbreakers = "1.183.0"
```

**Example usage:**
```rust
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 →](/help/article/rust-sdk-quickstart)

## Command-line interface (CLI)

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

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

**Authentication:**
```bash
linkbreakers auth set-token --token YOUR_WORKSPACE_TOKEN
```

**Common operations:**

```bash
# 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 →](/help/article/linkbreakers-cli-setup)

## 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

| Client | Platform | Setup Time |
|--------|----------|------------|
| **Claude** (web/desktop) | Browser, macOS, Windows | < 2 minutes |
| **Claude Code** | CLI (macOS, Linux, Windows) | < 1 minute |
| **Continue** | VSCode extension | < 3 minutes |

### Setup for Claude Code

```bash
claude mcp add --transport http linkbreakers https://mcp.linkbreakers.com
```

Your client handles OAuth sign-in automatically when you first connect.

### 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:

```typescript
// 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 →](/help/article/mcp-server-setup)

## API authentication

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

### Publishable keys

**Safe for frontend/browser use.**

```typescript
// 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.**

```bash
# 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

| Tool | Publishable Key | Secret Key |
|------|----------------|------------|
| TypeScript SDK (frontend) | ✅ Visitor tracking | ❌ Never |
| TypeScript SDK (backend) | ⚠️ Limited | ✅ Full access |
| Python SDK | ⚠️ Limited | ✅ Full access |
| Go SDK | ⚠️ Limited | ✅ Full access |
| Java SDK | ⚠️ Limited | ✅ Full access |
| Rust SDK | ⚠️ Limited | ✅ Full access |
| CLI | ❌ Not supported | ✅ Required |
| MCP Server | ❌ Not supported | ❌ Uses OAuth 2.0 |

## 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:**
```python
# 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:**
```typescript
// 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:**
```go
// 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:

```python
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:

```typescript
// 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:

```bash
#!/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
// 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. Each plan includes a monthly allowance of API calls made with workspace tokens:
- **Free plan:** 250 API calls a month
- **Light plan:** 5,000 API calls a month
- **Pro plan:** 10,000 API calls a month
- **Enterprise:** no monthly cap

Each token is also rate limited to 600 requests per 60 seconds.

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](https://github.com/linkbreakers-com/linkbreakers-typescript)
- [Python SDK on GitHub](https://github.com/linkbreakers-com/linkbreakers-python)
- [Go SDK on GitHub](https://github.com/linkbreakers-com/linkbreakers-go)
- [Java SDK on GitHub](https://github.com/linkbreakers-com/linkbreakers-java)
- [Rust SDK on GitHub](https://github.com/linkbreakers-com/linkbreakers-rust)
- [CLI on GitHub](https://github.com/linkbreakers-com/linkbreakers-cli)

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 the CLI
- Cannot be scoped to specific operations
- Long-lived credentials
- Note: The MCP server now uses OAuth 2.0 instead of workspace tokens

**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](/help/article/typescript-sdk-quickstart)
- **Writing backend services?** → Choose [Python](/help/article/python-sdk-quickstart), [Go](/help/article/golang-sdk-quickstart), [Java](/help/article/java-sdk-quickstart), or [Rust](/help/article/rust-sdk-quickstart)
- **Need terminal access?** → [Install the CLI](/help/article/linkbreakers-cli-setup)
- **Using AI assistants?** → [Configure MCP server](/help/article/mcp-server-setup)

### 2. Create API credentials

1. Log in to [app.linkbreakers.com](https://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
   - **MCP** uses OAuth 2.0 — no token needed

### 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](/help/article/typescript-sdk-quickstart)
- [Linkbreakers Python SDK Quick Start](/help/article/python-sdk-quickstart)
- [Linkbreakers Go SDK Quick Start](/help/article/golang-sdk-quickstart)
- [Linkbreakers Java SDK Quick Start](/help/article/java-sdk-quickstart)
- [Linkbreakers Rust SDK Quick Start](/help/article/rust-sdk-quickstart)

### Tools
- [How to install and use the Linkbreakers CLI](/help/article/linkbreakers-cli-setup)
- [How to set up and configure the Linkbreakers MCP server](/help/article/mcp-server-setup)
- [How Linkbreakers works with AI agents](/help/article/linkbreakers-for-ai-agents)

### API documentation
- [How to use the Linkbreakers API](/help/article/how-to-use-the-linkbreakers-api)
- [API authentication: Access tokens vs API keys](/help/article/api-authentication-accesstoken-vs-apikey)

## Last reviewed

This article was last reviewed on April 2, 2026.