URL Shortener API in 2026 Complete Guide to Cuttly Regular and Team API

Manual link shortening does not scale.

One link at a time works when you share one link at a time.
When your application generates thousands of links per day — for users, for campaigns, for notifications, for trackable documents — manual shortening is not a workflow. It is a bottleneck.

An API removes the bottleneck entirely.
Link creation, statistics retrieval, branded domain usage — all automated, all integrated, all running without human intervention.

This guide covers the complete Cuttly URL shortener API — Regular and Team — with practical examples in PHP, Python, JavaScript, and guidance on no-code automation options for teams who want API-level power without writing custom code.

Regular API vs Team API: Which Do You Need?

Cuttly provides two separate API systems for different use cases. Understanding which applies to your situation determines which documentation, authentication method and rate limits you work with.

For individual developers, SaaS products, personal automation and single-account workflows: use the Regular API. For organisations where multiple team members need to create links under shared workspaces and branded domains: use the Team API.

The Regular API is for one person building something.
The Team API is for a team building something together.

How to Get Your Cuttly API Key

Your API key authenticates every request to the Cuttly API. It identifies your account and determines your rate limits and available features.

Treat your API key like a password. Do not expose it in client-side code, public repositories or frontend JavaScript that users can inspect. Store it as an environment variable in server-side applications.

Link Shortening via API

The core API endpoint for shortening links is a simple GET request to:

Request Parameters

API Response Status Codes

When status is 7 (success), the response also includes:

• url.shortLink — the shortened URL
• url.fullLink — the original destination URL
• url.date — the date the link was created
• url.title — the page title of the destination

Code Examples

Here are ready-to-use examples in the four most common languages. Replace YOUR_API_KEY and YOUR_URL with your actual values.

PHP

$url = urlencode('https://yoursite.com/your-long-url');
$key = 'YOUR_API_KEY';
 
$json = file_get_contents(
    "https://cutt.ly/api/api.php?key={$key}&short={$url}"
);
 
$data = json_decode($json, true);
 
if ($data['url']['status'] === 7) {
    echo $data['url']['shortLink'];
} else {
    echo 'Error: status ' . $data['url']['status'];
}

Python

import urllib.parse
import requests
 
key = 'YOUR_API_KEY'
url = urllib.parse.quote('https://yoursite.com/your-long-url')
 
response = requests.get(
    f'https://cutt.ly/api/api.php?key={key}&short={url}'
)
 
data = response.json()
 
if data['url']['status'] == 7:
    print(data['url']['shortLink'])
else:
    print(f"Error: status {data['url']['status']}")

JavaScript (Node.js / fetch)

const key = 'YOUR_API_KEY';
const url = encodeURIComponent('https://yoursite.com/your-long-url');
 
const response = await fetch(
    `https://cutt.ly/api/api.php?key=${key}&short=${url}`
);
 
const data = await response.json();
 
if (data.url.status === 7) {
    console.log(data.url.shortLink);
} else {
    console.log(`Error: status ${data.url.status}`);
}

Java

URL url = new URL(
    "https://cutt.ly/api/api.php?key=YOUR_API_KEY&short="
    + URLEncoder.encode("https://yoursite.com/your-long-url", "UTF-8")
);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Accept", "application/json");
 
BufferedReader br = new BufferedReader(
    new InputStreamReader(conn.getInputStream())
);
String output;
StringBuilder sb = new StringBuilder();
while ((output = br.readLine()) != null) {
    sb.append(output);
}
conn.disconnect();
System.out.println(sb.toString());

Using a Branded Domain with the API

To create short links using your branded custom domain instead of cutt.ly, add the userDomain=1 parameter to your request. The API will use the active, approved domain connected to your account.

$url = urlencode('https://yoursite.com/page');
$key = 'YOUR_API_KEY';
 
$json = file_get_contents(
    "https://cutt.ly/api/api.php?key={$key}&short={$url}&userDomain=1"
);

Requirements for branded domain API usage:

• Any paid Cuttly subscription (Starter, Single, Team or Team Enterprise)
• A custom domain connected to your account with status: active and approved
• The userDomain=1 parameter included in the request

If you have multiple branded domains connected (Single plan supports 5, Team supports 10), the API uses the primary active domain. For multi-domain API management, the Team API provides more granular domain assignment control.

Requesting a Specific Slug via API

To request a specific custom slug for your short link, include the name parameter:

$url   = urlencode('https://yoursite.com/page');
$key   = 'YOUR_API_KEY';
$name  = 'summer-sale';
 
$json = file_get_contents(
    "https://cutt.ly/api/api.php?key={$key}&short={$url}&name={$name}"
);

If the requested slug is already taken, the API returns status 3. In this case, either choose a different slug or omit the name parameter to receive an auto-generated one.

Note that the name parameter is subject to the same monthly custom slug limit as your plan — 3 per month on free, 30 on Starter, unlimited on Single and above.

Retrieving Click Statistics via API

The Cuttly API includes a statistics endpoint that returns click data for links in your account. Full documentation is available at cutt.ly/api-documentation/regular-api.

Use cases for programmatic statistics retrieval:

• Building internal dashboards that display click data alongside other business metrics
• Automated weekly or monthly click reports sent via email or Slack
• Real-time monitoring systems that alert when a link's click count crosses a threshold
• Data pipelines that pull Cuttly click data into a data warehouse or BI tool
• SaaS applications where users see their own link analytics inside your product

API Rate Limits by Plan

Cuttly API rate limits are applied per 60-second window. Exceeding the limit returns a Too many requests error. Build retry logic with exponential backoff into any application that makes frequent API calls.

The monthly link limit is shared between links created in the dashboard and links created via API. There is no separate API-only allocation — all link creation counts toward the same monthly total regardless of how the link was created.

Handling API Errors Correctly

Robust API integrations handle errors gracefully rather than failing silently. Here are the errors you are most likely to encounter and how to handle each one.

Team API: Multi-User Link Management

The Team API — documented at cutt.ly/api-documentation/team-api — extends the Regular API for team environments. It is available on Team plans and operates at the team workspace level rather than the individual account level.

Key differences from the Regular API:

• Team-level authentication. The Team API uses a team API key rather than a personal key — allowing multiple team members to create links under the same workspace without sharing individual account credentials.
• Shared workspace links. All links created via the Team API appear in the team's shared dashboard, visible to all team members with appropriate permissions.
• Team branded domains. Use team-level branded domains — domains connected to the team workspace rather than an individual account — in API-created links.
• Higher rate limits. Team plans have higher API rate limits reflecting the higher-volume use cases teams typically have.

The Team API is the right choice for:

• Agencies creating short links for multiple clients under shared workspaces
• Marketing platforms that generate links on behalf of multiple users
• Organisations where a central system creates links consumed across multiple departments
• SaaS products that provision short links for their own customers using team infrastructure

No-Code API Integrations: Zapier, Make and More

Not every team that needs API-level link automation has developer resources. Cuttly's integrations with no-code and low-code platforms provide API functionality — automated link creation, data syncing — through visual workflow builders that require no programming knowledge.

Available integrations are listed at cutt.ly/resources/integrations.

Zapier

Zapier connects Cuttly to thousands of other applications through trigger-and-action workflows called Zaps. Both Regular and Team versions are available on Zapier.

Example Zapier workflows:

• New row added to Google Sheets → automatically create a Cuttly short link → write the short link back to the sheet
• New Typeform submission → shorten the confirmation page URL → send via email with the short link
• New WordPress post published → create a short link for the post → post to Slack channel
• New HubSpot contact → create a personalised short link → add to contact record

Make (formerly Integromat)

Make provides a visual workflow builder with more complex branching logic than Zapier, making it suitable for multi-step automation scenarios. Both Cuttly Regular and Team integrations are available.

Example Make scenarios:

• Batch process a list of URLs from Airtable → shorten each → store results in a new Airtable table
• Monitor a RSS feed → for each new item, create a short link → add to a Buffer social media queue
• New e-commerce order → generate a unique short link for the order status page → send via WhatsApp

Other Available Integrations

Beyond Zapier and Make, Cuttly connects to:

• Zoho Flow — for teams in the Zoho ecosystem
• OttoKit — automation platform with Cuttly native support
• Pabbly Connect — cost-effective alternative to Zapier for high-volume workflows
• ViaSocket — workflow automation with Cuttly integration
• Pipedream — developer-friendly workflow platform with code-level customisation

For AI-powered automation — connecting Cuttly to AI agents and autonomous workflow systems — Cuttly's AI Automation Hub at cutt.ly/resources/ai documents integrations with platforms including Lindy.ai, Whippy.ai and Relevance AI.

Common API Integration Patterns

Understanding the most common ways developers use the Cuttly API helps you design your integration correctly from the start.

Pattern 1 — On-Demand Link Creation

The simplest pattern: a user or system action triggers a link creation request. The API returns the short link, which is immediately displayed or stored.

Examples: a CMS plugin that automatically shortens each new post URL on publish, a CRM that creates a personalised short link for each sales prospect, a marketing tool that shortens each campaign URL as it is configured.

Pattern 2 — Batch Processing

A list of URLs is processed in sequence, with each URL shortened and the results collected. Respect rate limits — implement delays between requests to stay within the allowed requests-per-60-seconds window for your plan.

For bulk shortening of very large lists (thousands of URLs), the CSV bulk import in the Cuttly dashboard may be more efficient than repeated API calls — available on the Single plan (100 links/month) and Team plans (2,000–5,000 links/month).

Pattern 3 — Link-Per-User

Each user of your application receives a unique short link pointing to a personalised destination. The API creates these links programmatically at user creation or first action. Analytics from each user's unique link flow back through the API statistics endpoint into your application's reporting.

This pattern is common in referral programs, affiliate tracking, personalised campaign landing pages and user-specific document sharing.

Pattern 4 — Dynamic Redirect Management

Short links are created once and their destinations are updated as content changes. The same short link — printed on physical materials, embedded in emails, shared on social — always points to the most current destination. The API handles both creation and destination updates programmatically.

Best Practices for URL Shortener API Integration

• Always URL-encode the destination URL. The short parameter must be properly URL-encoded before being passed to the API. Use urlencode() in PHP, urllib.parse.quote() in Python, or encodeURIComponent() in JavaScript. Failing to encode correctly is the most common cause of status 5 errors.
• Store the API key as an environment variable. Never hardcode your API key into source code that might be committed to a repository. Use environment variables or a secrets management system.
• Handle all status codes explicitly. Do not assume status 7 (success) — check the status code on every response and handle each case. A status 8 (limit reached) should trigger an alert, not a silent failure.
• Implement exponential backoff for rate limit errors. When you receive a "too many requests" error, wait before retrying — and increase the wait time on each successive failure. A naive retry loop will simply hit the rate limit repeatedly.
• Cache short links where possible. If your application shortens the same URL repeatedly, cache the result instead of making a new API call each time. The API returns status 1 for URLs it has already shortened from your domain, but caching avoids the round trip entirely.
• Test with the free plan before scaling. The free plan's 3 requests/60s limit is enough to validate your integration logic before committing to a paid plan for production volume.
• Use the name parameter thoughtfully. Requesting a specific slug risks a status 3 collision if the slug is taken. For high-volume automated link creation, omit name and use auto-generated slugs — or generate slugs with enough uniqueness (timestamp-based, UUID-based) to avoid collisions.

Final Verdict

A URL shortener API turns a manual, one-at-a-time process into infrastructure.
Links that previously required a human to create, customise and manage are created, customised and managed automatically — at whatever volume your application requires.

Cuttly's API is straightforward by design. A single GET request. A JSON response. Clear status codes. Rate limits that scale with your plan. And the same branded domain, analytics and feature set available via API that you access in the dashboard.

For teams without developer resources, the no-code integrations — Zapier, Make, Zoho Flow and others — provide the same automation capability through visual workflow builders that require no code.

The API does not add new features to your link management.
It removes the only constraint that was left: the need for a human to press the button.