Build a Bulk Link Generator

mkdir sniplink-bulk-generator
cd sniplink-bulk-generator
npm init -y
npm install node-fetch csv-parse csv-stringify dotenv

SNIPLINK_API_KEY=snip_live_your_api_key_here
SNIPLINK_WORKSPACE_ID=ws_xxxxxxxxxxxxx

mkdir sniplink-bulk-generator
cd sniplink-bulk-generator
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install requests python-dotenv

SNIPLINK_API_KEY=snip_live_your_api_key_here
SNIPLINK_WORKSPACE_ID=ws_xxxxxxxxxxxxx

mkdir sniplink-bulk-generator
cd sniplink-bulk-generator
npm init -y
npm install tsx
npm install -D typescript @types/node
npm install csv-parse csv-stringify dotenv
npx tsc --init

url,slug,title,tags
https://example.com/product/awesome-widget,awesome-widget,Awesome Widget Product Page,"product,widgets"
https://example.com/blog/how-to-start,blog-start,How to Get Started,"blog,tutorial"
https://example.com/pricing,pricing-2026,Pricing 2026,"pricing,sales"
https://example.com/contact,contact,Contact Us,"support,contact"

// rateLimiter.js
class RateLimiter {
  constructor(maxRequests = 100, windowMs = 15 * 60 * 1000) {
    this.maxRequests = maxRequests;  // 100 requests
    this.windowMs = windowMs;        // 15 minutes in milliseconds
    this.tokens = maxRequests;       // Start with full bucket
    this.lastRefill = Date.now();
  }

  async acquire() {
    this.refill();

    if (this.tokens > 0) {
      this.tokens--;
      return;
    }

    // No tokens available - calculate wait time
    const timeUntilRefill = this.windowMs - (Date.now() - this.lastRefill);
    console.log(`Rate limit reached. Waiting ${Math.ceil(timeUntilRefill / 1000)}s...`);

    await this.sleep(timeUntilRefill);
    this.refill();
    this.tokens--;
  }

  refill() {
    const now = Date.now();
    const timePassed = now - this.lastRefill;

    if (timePassed >= this.windowMs) {
      this.tokens = this.maxRequests;
      this.lastRefill = now;
    }
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

module.exports = { RateLimiter };

# rate_limiter.py
import time
from datetime import datetime, timedelta

class RateLimiter:
    def __init__(self, max_requests=100, window_seconds=900):
        self.max_requests = max_requests  # 100 requests
        self.window_seconds = window_seconds  # 15 minutes = 900 seconds
        self.tokens = max_requests
        self.last_refill = time.time()

    def acquire(self):
        self._refill()

        if self.tokens > 0:
            self.tokens -= 1
            return

        # No tokens available - calculate wait time
        time_until_refill = self.window_seconds - (time.time() - self.last_refill)
        print(f"Rate limit reached. Waiting {int(time_until_refill)}s...")

        time.sleep(time_until_refill)
        self._refill()
        self.tokens -= 1

    def _refill(self):
        now = time.time()
        time_passed = now - self.last_refill

        if time_passed >= self.window_seconds:
            self.tokens = self.max_requests
            self.last_refill = now

// rateLimiter.ts
export class RateLimiter {
  private tokens: number;
  private lastRefill: number;

  constructor(
    private maxRequests: number = 100,
    private windowMs: number = 15 * 60 * 1000
  ) {
    this.tokens = maxRequests;
    this.lastRefill = Date.now();
  }

  async acquire(): Promise<void> {
    this.refill();

    if (this.tokens > 0) {
      this.tokens--;
      return;
    }

    // No tokens available - calculate wait time
    const timeUntilRefill = this.windowMs - (Date.now() - this.lastRefill);
    console.log(`Rate limit reached. Waiting ${Math.ceil(timeUntilRefill / 1000)}s...`);

    await this.sleep(timeUntilRefill);
    this.refill();
    this.tokens--;
  }

  private refill(): void {
    const now = Date.now();
    const timePassed = now - this.lastRefill;

    if (timePassed >= this.windowMs) {
      this.tokens = this.maxRequests;
      this.lastRefill = now;
    }
  }

  private sleep(ms: number): Promise<void> {
    return new Promise((resolve) => setTimeout(resolve, ms));
  }
}

// linkCreator.js
require('dotenv').config();
const fetch = require('node-fetch');

const API_BASE = 'https://api.sniplink.co/v1';
const API_KEY = process.env.SNIPLINK_API_KEY;
const WORKSPACE_ID = process.env.SNIPLINK_WORKSPACE_ID;

async function createLink(linkData, rateLimiter, retries = 3) {
  for (let attempt = 1; attempt <= retries; attempt++) {
    try {
      // Wait for rate limiter to allow the request
      await rateLimiter.acquire();

      const response = await fetch(
        `${API_BASE}/workspaces/${WORKSPACE_ID}/links`,
        {
          method: &#039;POST&#039;,
          headers: {
            &#039;X-API-Key&#039;: API_KEY,
            &#039;Content-Type&#039;: &#039;application/json&#039;,
          },
          body: JSON.stringify(linkData),
        }
      );

      const data = await response.json();

      if (response.ok) {
        return {
          success: true,
          link: data.link,
        };
      }

      // Handle specific error cases
      if (response.status === 409) {
        // Slug already exists
        return {
          success: false,
          error: `Slug '${linkData.slug}' already exists`,
          code: &#039;SLUG_EXISTS&#039;,
        };
      }

      if (response.status === 403) {
        // Feature not available on current plan
        return {
          success: false,
          error: data.message || &#039;Feature not available on your plan&#039;,
          code: &#039;PLAN_LIMIT&#039;,
        };
      }

      if (response.status === 429) {
        // Rate limit hit (shouldn't happen with our rate limiter, but handle it)
        const waitTime = 60 * 1000; // Wait 1 minute
        console.log(`API rate limit hit. Waiting ${waitTime / 1000}s...`);
        await new Promise(resolve => setTimeout(resolve, waitTime));
        continue; // Retry
      }

      if (response.status >= 500) {
        // Server error - retry with exponential backoff
        if (attempt < retries) {
          const backoff = Math.pow(2, attempt) * 1000; // 2s, 4s, 8s
          console.log(`Server error. Retrying in ${backoff / 1000}s...`);
          await new Promise(resolve => setTimeout(resolve, backoff));
          continue;
        }
      }

      // Other client errors (400, etc.)
      return {
        success: false,
        error: data.message || &#039;Unknown error&#039;,
        code: &#039;API_ERROR&#039;,
      };
    } catch (error) {
      if (attempt < retries) {
        const backoff = Math.pow(2, attempt) * 1000;
        console.log(`Network error. Retrying in ${backoff / 1000}s...`);
        await new Promise(resolve => setTimeout(resolve, backoff));
        continue;
      }

      return {
        success: false,
        error: error.message,
        code: &#039;NETWORK_ERROR&#039;,
      };
    }
  }

  return {
    success: false,
    error: &#039;Max retries exceeded&#039;,
    code: &#039;MAX_RETRIES&#039;,
  };
}

module.exports = { createLink };

# link_creator.py
import os
import time
import requests
from dotenv import load_dotenv

load_dotenv()

API_BASE = 'https://api.sniplink.co/v1'
API_KEY = os.getenv('SNIPLINK_API_KEY')
WORKSPACE_ID = os.getenv('SNIPLINK_WORKSPACE_ID')

def create_link(link_data, rate_limiter, retries=3):
    for attempt in range(1, retries + 1):
        try:
            # Wait for rate limiter to allow the request
            rate_limiter.acquire()

            response = requests.post(
                f'{API_BASE}/workspaces/{WORKSPACE_ID}/links',
                headers={
                    'X-API-Key': API_KEY,
                    'Content-Type': 'application/json',
                },
                json=link_data,
            )

            if response.ok:
                data = response.json()
                return {
                    'success': True,
                    'link': data['link'],
                }

            data = response.json() if response.headers.get('content-type') == 'application/json' else {}

            # Handle specific error cases
            if response.status_code == 409:
                return {
                    'success': False,
                    'error': f"Slug '{link_data.get('slug')}' already exists",
                    'code': 'SLUG_EXISTS',
                }

            if response.status_code == 403:
                return {
                    'success': False,
                    'error': data.get('message', 'Feature not available on your plan'),
                    'code': 'PLAN_LIMIT',
                }

            if response.status_code == 429:
                wait_time = 60  # Wait 1 minute
                print(f'API rate limit hit. Waiting {wait_time}s...')
                time.sleep(wait_time)
                continue  # Retry

            if response.status_code >= 500:
                if attempt < retries:
                    backoff = 2 ** attempt  # 2s, 4s, 8s
                    print(f&#039;Server error. Retrying in {backoff}s...')
                    time.sleep(backoff)
                    continue

            # Other client errors
            return {
                &#039;success': False,
                &#039;error': data.get('message', 'Unknown error'),
                &#039;code': 'API_ERROR',
            }

        except requests.exceptions.RequestException as error:
            if attempt < retries:
                backoff = 2 ** attempt
                print(f&#039;Network error. Retrying in {backoff}s...')
                time.sleep(backoff)
                continue

            return {
                &#039;success': False,
                &#039;error': str(error),
                &#039;code': 'NETWORK_ERROR',
            }

    return {
        &#039;success': False,
        &#039;error': 'Max retries exceeded',
        &#039;code': 'MAX_RETRIES',
    }

// linkCreator.ts
import 'dotenv/config';
import { RateLimiter } from './rateLimiter';

const API_BASE = 'https://api.sniplink.co/v1';
const API_KEY = process.env.SNIPLINK_API_KEY!;
const WORKSPACE_ID = process.env.SNIPLINK_WORKSPACE_ID!;

interface LinkData {
  url: string;
  slug?: string;
  title?: string;
  tags?: string[];
  expiresAt?: string;
  password?: string;
}

interface CreateLinkResult {
  success: boolean;
  link?: any;
  error?: string;
  code?: string;
}

export async function createLink(
  linkData: LinkData,
  rateLimiter: RateLimiter,
  retries = 3
): Promise<CreateLinkResult> {
  for (let attempt = 1; attempt <= retries; attempt++) {
    try {
      await rateLimiter.acquire();

      const response = await fetch(
        `${API_BASE}/workspaces/${WORKSPACE_ID}/links`,
        {
          method: &#039;POST&#039;,
          headers: {
            &#039;X-API-Key&#039;: API_KEY,
            &#039;Content-Type&#039;: &#039;application/json&#039;,
          },
          body: JSON.stringify(linkData),
        }
      );

      const data = await response.json();

      if (response.ok) {
        return {
          success: true,
          link: data.link,
        };
      }

      // Handle specific error cases
      if (response.status === 409) {
        return {
          success: false,
          error: `Slug '${linkData.slug}' already exists`,
          code: &#039;SLUG_EXISTS&#039;,
        };
      }

      if (response.status === 403) {
        return {
          success: false,
          error: data.message || &#039;Feature not available on your plan&#039;,
          code: &#039;PLAN_LIMIT&#039;,
        };
      }

      if (response.status === 429) {
        const waitTime = 60 * 1000;
        console.log(`API rate limit hit. Waiting ${waitTime / 1000}s...`);
        await new Promise((resolve) => setTimeout(resolve, waitTime));
        continue;
      }

      if (response.status >= 500) {
        if (attempt < retries) {
          const backoff = Math.pow(2, attempt) * 1000;
          console.log(`Server error. Retrying in ${backoff / 1000}s...`);
          await new Promise((resolve) => setTimeout(resolve, backoff));
          continue;
        }
      }

      return {
        success: false,
        error: data.message || &#039;Unknown error&#039;,
        code: &#039;API_ERROR&#039;,
      };
    } catch (error) {
      if (attempt < retries) {
        const backoff = Math.pow(2, attempt) * 1000;
        console.log(`Network error. Retrying in ${backoff / 1000}s...`);
        await new Promise((resolve) => setTimeout(resolve, backoff));
        continue;
      }

      return {
        success: false,
        error: error instanceof Error ? error.message : &#039;Unknown error&#039;,
        code: &#039;NETWORK_ERROR&#039;,
      };
    }
  }

  return {
    success: false,
    error: &#039;Max retries exceeded&#039;,
    code: &#039;MAX_RETRIES&#039;,
  };
}

// index.js
const fs = require('fs');
const { parse } = require('csv-parse/sync');
const { stringify } = require('csv-stringify/sync');
const { RateLimiter } = require('./rateLimiter');
const { createLink } = require('./linkCreator');

async function main() {
  console.log('🚀 SnipLink Bulk Link Generator\n');

  // Read input CSV
  const inputFile = process.argv[2] || 'links.csv';
  const csvContent = fs.readFileSync(inputFile, 'utf-8');
  const records = parse(csvContent, { columns: true, skip_empty_lines: true });

  console.log(`📄 Found ${records.length} URLs to process\n`);

  // Initialize rate limiter
  const rateLimiter = new RateLimiter();

  // Process links
  const results = [];
  let successCount = 0;
  let errorCount = 0;

  for (let i = 0; i < records.length; i++) {
    const record = records[i];
    const linkData = {
      url: record.url,
      ...(record.slug && { slug: record.slug }),
      ...(record.title && { title: record.title }),
      ...(record.tags && { tags: record.tags.split(&#039;,&#039;).map(t => t.trim()) }),
      ...(record.expiresAt && { expiresAt: record.expiresAt }),
      ...(record.password && { password: record.password }),
    };

    console.log(`[${i + 1}/${records.length}] Processing: ${record.url}`);

    const result = await createLink(linkData, rateLimiter);

    if (result.success) {
      console.log(`  ✅ Created: ${result.link.shortUrl}`);
      successCount++;
      results.push({
        ...record,
        status: &#039;success&#039;,
        shortUrl: result.link.shortUrl,
        linkId: result.link.id,
      });
    } else {
      console.log(`  ❌ Failed: ${result.error}`);
      errorCount++;
      results.push({
        ...record,
        status: &#039;error&#039;,
        error: result.error,
        errorCode: result.code,
      });
    }
  }

  // Write results to CSV
  const outputFile = &#039;results.csv&#039;;
  const csvOutput = stringify(results, { header: true });
  fs.writeFileSync(outputFile, csvOutput);

  console.log(`\n✨ Done!\n`);
  console.log(`  ✅ Successful: ${successCount}`);
  console.log(`  ❌ Failed: ${errorCount}`);
  console.log(`  📊 Results saved to: ${outputFile}\n`);
}

main().catch(console.error);

# main.py
import csv
import sys
from rate_limiter import RateLimiter
from link_creator import create_link

def main():
    print('🚀 SnipLink Bulk Link Generator\n')

    # Read input CSV
    input_file = sys.argv[1] if len(sys.argv) > 1 else 'links.csv'

    with open(input_file, 'r', encoding='utf-8') as f:
        reader = csv.DictReader(f)
        records = list(reader)

    print(f'📄 Found {len(records)} URLs to process\n')

    # Initialize rate limiter
    rate_limiter = RateLimiter()

    # Process links
    results = []
    success_count = 0
    error_count = 0

    for i, record in enumerate(records):
        link_data = {'url': record['url']}

        if record.get('slug'):
            link_data['slug'] = record['slug']
        if record.get('title'):
            link_data['title'] = record['title']
        if record.get('tags'):
            link_data['tags'] = [t.strip() for t in record['tags'].split(',')]
        if record.get('expiresAt'):
            link_data['expiresAt'] = record['expiresAt']
        if record.get('password'):
            link_data['password'] = record['password']

        print(f'[{i + 1}/{len(records)}] Processing: {record["url"]}')

        result = create_link(link_data, rate_limiter)

        if result['success']:
            print(f'  ✅ Created: {result["link"]["shortUrl"]}')
            success_count += 1
            results.append({
                **record,
                'status': 'success',
                'shortUrl': result['link']['shortUrl'],
                'linkId': result['link']['id'],
            })
        else:
            print(f'  ❌ Failed: {result["error"]}')
            error_count += 1
            results.append({
                **record,
                'status': 'error',
                'error': result['error'],
                'errorCode': result.get('code'),
            })

    # Write results to CSV
    output_file = 'results.csv'

    if results:
        with open(output_file, 'w', encoding='utf-8', newline='') as f:
            fieldnames = list(results[0].keys())
            writer = csv.DictWriter(f, fieldnames=fieldnames)
            writer.writeheader()
            writer.writerows(results)

    print('\n✨ Done!\n')
    print(f'  ✅ Successful: {success_count}')
    print(f'  ❌ Failed: {error_count}')
    print(f'  📊 Results saved to: {output_file}\n')

if __name__ == '__main__':
    main()

// index.ts
import fs from 'fs';
import { parse } from 'csv-parse/sync';
import { stringify } from 'csv-stringify/sync';
import { RateLimiter } from './rateLimiter';
import { createLink } from './linkCreator';

async function main() {
  console.log('🚀 SnipLink Bulk Link Generator\n');

  // Read input CSV
  const inputFile = process.argv[2] || 'links.csv';
  const csvContent = fs.readFileSync(inputFile, 'utf-8');
  const records = parse(csvContent, { columns: true, skip_empty_lines: true });

  console.log(`📄 Found ${records.length} URLs to process\n`);

  // Initialize rate limiter
  const rateLimiter = new RateLimiter();

  // Process links
  const results: any[] = [];
  let successCount = 0;
  let errorCount = 0;

  for (let i = 0; i < records.length; i++) {
    const record = records[i];
    const linkData: any = {
      url: record.url,
      ...(record.slug && { slug: record.slug }),
      ...(record.title && { title: record.title }),
      ...(record.tags && { tags: record.tags.split(&#039;,&#039;).map((t: string) => t.trim()) }),
      ...(record.expiresAt && { expiresAt: record.expiresAt }),
      ...(record.password && { password: record.password }),
    };

    console.log(`[${i + 1}/${records.length}] Processing: ${record.url}`);

    const result = await createLink(linkData, rateLimiter);

    if (result.success) {
      console.log(`  ✅ Created: ${result.link.shortUrl}`);
      successCount++;
      results.push({
        ...record,
        status: &#039;success&#039;,
        shortUrl: result.link.shortUrl,
        linkId: result.link.id,
      });
    } else {
      console.log(`  ❌ Failed: ${result.error}`);
      errorCount++;
      results.push({
        ...record,
        status: &#039;error&#039;,
        error: result.error,
        errorCode: result.code,
      });
    }
  }

  // Write results to CSV
  const outputFile = &#039;results.csv&#039;;
  const csvOutput = stringify(results, { header: true });
  fs.writeFileSync(outputFile, csvOutput);

  console.log(`\n✨ Done!\n`);
  console.log(`  ✅ Successful: ${successCount}`);
  console.log(`  ❌ Failed: ${errorCount}`);
  console.log(`  📊 Results saved to: ${outputFile}\n`);
}

main().catch(console.error);

node index.js links.csv

python main.py links.csv

npx tsx index.ts links.csv

🚀 SnipLink Bulk Link Generator

📄 Found 4 URLs to process

[1/4] Processing: https://example.com/product/awesome-widget
  ✅ Created: https://r.sniplink.co/awesome-widget
[2/4] Processing: https://example.com/blog/how-to-start
  ✅ Created: https://r.sniplink.co/blog-start
[3/4] Processing: https://example.com/pricing
  ✅ Created: https://r.sniplink.co/pricing-2026
[4/4] Processing: https://example.com/contact
  ✅ Created: https://r.sniplink.co/contact

✨ Done!

  ✅ Successful: 4
  ❌ Failed: 0
  📊 Results saved to: results.csv

if (result.code === 'SLUG_EXISTS') {
  // Try again with a timestamp suffix
  linkData.slug = `${linkData.slug}-${Date.now()}`;
  result = await createLink(linkData, rateLimiter);
}

// Process in chunks of 100
const BATCH_SIZE = 100;
for (let i = 0; i < records.length; i += BATCH_SIZE) {
  const batch = records.slice(i, i + BATCH_SIZE);
  await processBatch(batch);

  // Save intermediate results
  fs.writeFileSync(&#039;results-partial.csv&#039;, stringify(results, { header: true }));
}

// Before processing, check if results file exists
if (fs.existsSync('results.csv')) {
  const existing = parse(fs.readFileSync('results.csv', 'utf-8'), { columns: true });
  const processedUrls = new Set(existing.map(r => r.url));
  records = records.filter(r => !processedUrls.has(r.url));
  results.push(...existing);
}

const winston = require('winston');
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' }),
  ],
});

// Log each API call
logger.info('Creating link', { url: linkData.url, slug: linkData.slug });

console.log(`Rate limit: ${rateLimiter.tokens}/${rateLimiter.maxRequests} requests available`);