Developer Community Launch Plan¶

Positioning¶

Lead with the use case, not "URL shortener":

Primary: "Turn any QR code into a webhook trigger with custom data"
Secondary: "The missing link between physical events and your API"
Tertiary: "Shortlinks that carry context to your webhooks"

Key message: This is about connecting the physical world (QR scans on packaging, flyers, badges) to your digital workflows. The shortlink is the mechanism, not the value proposition.

1. Hacker News — Show HN Post¶

Title:

Show HN: yousnap.me – Shortlinks that carry JSON data to your webhooks

Body:

Hi HN,

I built yousnap.me — a shortlink API that attaches custom JSON data to every link. When someone clicks the link (or scans its QR code), your webhooks fire instantly with that data.

The core idea: Connect physical events to your digital workflows. Put a QR code on product packaging with SKU and batch data — when scanned, it hits your inventory webhook. Print flyers with campaign metadata — every click delivers attribution to your analytics. Create name badges with attendee info — each scan triggers your registration system.

The API is simple: - POST /shorten with your redirect URL, JSON data, and webhook URLs - Get back a short link (usnp.me/abc123) - Every click/scan sends your data to your webhooks with HMAC signature verification - Generate QR codes in PNG or SVG with custom colors (including CMYK for print)

It's built on FastAPI and Supabase. Five core endpoints, OpenAPI docs at usnp.me/docs. The free tier gives you 100 links and 1,000 webhook deliveries per month. Pro tier ($19/mo) is unlimited links with 50,000 webhook deliveries.

I built this after repeatedly needing to bridge physical touchpoints (QR codes on conference materials, product labels, printed ads) with backend systems. Existing URL shorteners didn't let you attach structured data or deliver it reliably via webhooks.

Links: - Landing page: https://yousnap.me - Developer docs: https://yousnap.me/docs - API playground: https://usnp.me/docs - Quickstart: https://yousnap.me/docs/quickstart/

What would you build with this? I'm curious what use cases I haven't thought of.

2. Reddit Posts¶

r/SideProject¶

Title:

I built a webhook-powered URL shortener for connecting physical stuff to APIs

Body:

What it is: yousnap.me lets you create shortlinks that carry custom JSON data. When someone clicks the link, your webhooks fire with that data.

Why I built it: I kept running into scenarios where I needed to connect physical events to my backend: - QR codes on product packaging that trigger inventory updates - Flyers with campaign metadata that hit analytics webhooks - Conference badges that fire Slack notifications when scanned

URL shorteners exist, but none let you attach structured data and deliver it via webhooks with proper signature verification. I wanted something designed for developers who think in APIs.

The tech: - FastAPI backend, Supabase for storage - Five endpoints: create link, redirect, generate QR code, check webhook status, view usage - Rate limiting, usage quotas, HMAC-signed webhook payloads - QR generation supports custom colors (hex RGB and CMYK for print) in PNG or SVG - Full OpenAPI docs at usnp.me/docs

Pricing: - Free tier: 100 links/month, 1,000 webhook deliveries - Pro ($19/mo): Unlimited links, 50,000 webhook deliveries

Links: - Try it: https://yousnap.me - Docs: https://yousnap.me/docs - API playground: https://usnp.me/docs

Happy to answer questions about the architecture or use cases!

r/webdev¶

Title:

I built an API that turns shortlinks into webhook triggers — here's the architecture

Body:

TL;DR: Built yousnap.me, a FastAPI service that creates shortlinks carrying JSON payloads. Every click fires webhooks with the data. Here's how it works.

The problem: URL shorteners track clicks, but they don't let you: 1. Attach custom structured data to a link 2. Deliver that data to your backend when clicked 3. Verify webhook authenticity with signatures

I needed this for connecting QR codes on physical materials (packaging, flyers, badges) to backend workflows.

Architecture: - Stack: FastAPI + Supabase (PostgreSQL + row-level security) - Three tables: links, webhooks (many-to-one with links), hits - Async webhook delivery: Background tasks with exponential backoff, 3 retries - Security: HMAC-SHA256 signature on every webhook payload, API key auth - Rate limiting: Token bucket per API key (10/min free, 60/min pro) - QR generation: qrcode-artistic library with PNG/SVG output, custom colors including CMYK conversion for print

The flow: 1. POST /shorten with redirect_url, data (JSON), webhooks (array of URLs) 2. Generate collision-resistant short_id (base62, 6 chars) 3. On GET /{short_id}: 302 redirect + background task to record hit and POST to all webhook URLs 4. Webhook payload includes event type, short_id, hit metadata, and your custom data 5. Signature in X-Webhook-Signature header for verification

Code example:

import requests

response = requests.post(
    "https://usnp.me/shorten",
    headers={"X-API-Key": "your-key"},
    json={
        "redirect_url": "https://example.com/product",
        "data": {"sku": "WIDGET-42", "campaign": "summer"},
        "webhooks": ["https://your-api.com/webhook"]
    }
)
# Returns: {"short_url": "https://usnp.me/abc123", ...}

When someone visits usnp.me/abc123, your webhook receives:

{
  "event": "hit",
  "short_id": "abc123",
  "hit_at": "2026-05-13T10:30:00Z",
  "data": {"sku": "WIDGET-42", "campaign": "summer"}
}

Challenges solved: - Webhook delivery reliability (retries, timeouts, failure tracking) - Preventing short_id collisions at scale - Rate limiting that doesn't kill performance (in-memory token buckets with Redis later) - CMYK to RGB conversion for print-ready QR codes

Try it: - Docs: https://yousnap.me/docs - Swagger UI: https://usnp.me/docs - Free tier: 100 links/month, 1k webhook deliveries

Open to feedback on the architecture. Considering open-sourcing it if there's interest.

r/InternetIsBeautiful¶

Title:

yousnap.me — QR codes that fire webhooks with custom JSON data

Body:

Just launched yousnap.me — a shortlink API for developers that bridges the physical and digital world.

What makes it different: Most URL shorteners just track clicks. This one lets you attach JSON data to a link and fires your webhooks every time it's clicked or scanned.

Example use case: Put a QR code on product packaging with SKU and batch data. When someone scans it, your inventory system gets a webhook with that data. The customer gets redirected to the product page, you get real-time tracking, and there's no app to install or form to fill.

Other uses: - Campaign attribution: Links carry campaign metadata to your analytics - Event triggers: Link clicks start workflows, send Slack messages, update dashboards - Print materials: Flyers and posters with context-aware QR codes

For developers: - Simple REST API (POST to create, GET to redirect) - HMAC-signed webhook payloads - QR code generation with custom colors (PNG and SVG) - Free tier: 100 links/month, 1,000 webhook deliveries

Links: - Try it: https://yousnap.me - Docs: https://yousnap.me/docs

3. Twitter/Bluesky Thread¶

Tweet 1 (Hook):

I built an API that makes QR codes fire webhooks.

Put a QR on your product packaging with SKU data. When scanned: customer → product page, your inventory API → gets the data.

No app. No form. Just a link that carries context.

🧵

Tweet 2 (The Problem):

The problem: URL shorteners track clicks but don't let you attach structured data or deliver it to your backend.

You can't put metadata in a link and have it arrive at your webhook when someone scans it.

That's what yousnap.me does.

Tweet 3 (How It Works - Step 1):

How it works:

1. POST /shorten with your data and webhook URL

{
  "redirect_url": "https://shop.com/widget",
  "data": {"sku": "W-42", "batch": "2026-Q2"},
  "webhooks": ["https://your-api.com/inventory"]
}

You get back: usnp.me/abc123

Tweet 4 (How It Works - Step 2):

2. Print the QR code (or share the link)

GET /abc123/qr?format=png&scale=10

Custom colors (including CMYK for print), PNG or SVG. Stick it on packaging, flyers, whatever.

Tweet 5 (How It Works - Step 3):

3. Someone scans it

→ They go to your product page
→ Your webhook fires with the JSON data + signature

{
  "event": "hit",
  "short_id": "abc123",
  "hit_at": "2026-05-13T10:30:00Z",
  "data": {"sku": "W-42", "batch": "2026-Q2"}
}

Tweet 6 (What People Are Building):

What people are building:

• Product packaging → inventory webhooks
• Conference badges → attendee check-in systems
• Print ads → campaign attribution
• Name tags → CRM updates
• Loyalty cards → reward triggers

Anything where scanning should trigger your code.

Tweet 7 (Call to Action):

Free tier: 100 links/month, 1,000 webhook deliveries
Pro ($19/mo): Unlimited links, 50k deliveries

Docs: yousnap.me/docs
API playground: usnp.me/docs
Try it: yousnap.me

What would you build? 👀

4. Indie Hackers Post¶

Title:

Launched yousnap.me — webhook-powered shortlinks for developers

Body:

What I built: yousnap.me is a shortlink API that attaches JSON data to every link. When clicked/scanned, your webhooks fire with that data. Think of it as the missing piece between physical touchpoints (QR codes on packaging, flyers, badges) and your digital workflows.

Why this exists: I kept running into the same pattern: needing to connect something physical to a backend system. QR codes on conference materials that should update a registration system. Product labels that trigger inventory webhooks. Print ads with campaign data that should hit analytics.

URL shorteners exist, but they're built for marketers tracking clicks, not developers building integrations. I wanted something that: 1. Lets you attach structured data (JSON) to a link 2. Delivers that data reliably via webhooks 3. Signs payloads so you can verify authenticity 4. Generates print-ready QR codes with custom colors

The tech: FastAPI backend on DigitalOcean, Supabase for storage. Five endpoints: create link, redirect, generate QR, check webhook delivery status, view usage. Full OpenAPI docs, rate limiting, HMAC signature verification on webhooks.

Took about 3 weeks to build, mostly nights/weekends. The hardest part was webhook delivery reliability — handling timeouts, retries, and tracking failures without blocking the redirect.

Business model: - Free tier: 100 links/month, 1,000 webhook deliveries - Pro tier: $19/month, unlimited links, 50,000 webhook deliveries

Going after developers first. The target customer is someone building internal tools, side projects, or small SaaS apps who needs to connect physical events to APIs without running their own infrastructure.

Early traction: Soft-launched to a few developer communities two weeks ago. Currently at 23 signups, 8 active users, ~400 links created. No revenue yet (everyone on free tier while I validate demand). Planning to gate Pro features next week and see if anyone converts.

What's next: 1. Finish the landing page (it's live but minimal) 2. Launch on Product Hunt, Hacker News, relevant subreddits 3. Add Stripe integration for Pro tier self-service 4. Build a simple dashboard (right now it's API-only) 5. Open-source it if there's enough interest and no revenue traction by Q3

The bet: Developers need infrastructure for webhook-driven workflows. Most build this themselves (shortlink + data storage + webhook queue) or use enterprise tools that are overkill. There's a gap for a simple, developer-focused API that just works.

Ask: If you've ever needed to attach data to a link or trigger webhooks from QR scans, I'd love your feedback. What would make this more useful?

Links: - Product: https://yousnap.me - Docs: https://yousnap.me/docs - API playground: https://usnp.me/docs

Happy to answer questions about the tech stack, business model, or go-to-market!

5. Dev.to / Hashnode Tutorial¶

Title:

How to build a QR-to-webhook pipeline in 5 minutes with yousnap.me

Intro:

Imagine this: You're running a pop-up shop. Each product has a QR code on the packaging. When a customer scans it, two things happen: 1. They're redirected to the product page 2. Your inventory system gets a webhook with the SKU and purchase intent

No app to download. No form to fill. Just a link that carries data.

In this tutorial, we'll build exactly that using yousnap.me — a shortlink API that fires webhooks with custom JSON data on every click.

What we'll build: - A product shortlink carrying SKU and campaign data - A webhook receiver that logs scans and could update inventory - A QR code you can print and test

Prerequisites: - A terminal and curl (or Postman) - A way to receive webhooks (we'll use webhook.site for testing, but I'll show a real FastAPI receiver too) - An API key from yousnap.me (free tier is fine)

Time to complete: 5 minutes

Full Tutorial Outline:

Step 1: Get your API key (30 seconds)¶

Sign up at yousnap.me (or use the waitlist endpoint to request access)
Save your API key

Step 2: Set up a webhook receiver (1 minute)¶

Option A: Quick test with webhook.site - Go to webhook.site - Copy your unique URL - You'll use this to see incoming payloads

Option B: Real receiver (FastAPI)

from fastapi import FastAPI, Request, HTTPException
import hmac
import hashlib

app = FastAPI()

WEBHOOK_SECRET = "your-webhook-secret-from-usnap"

@app.post("/webhook")
async def receive_webhook(request: Request):
    # Get the signature from headers
    signature = request.headers.get("X-Webhook-Signature")
    if not signature:
        raise HTTPException(status_code=401, detail="Missing signature")

    # Read the body
    body = await request.body()

    # Verify the signature
    expected = hmac.new(
        WEBHOOK_SECRET.encode(),
        body,
        hashlib.sha256
    ).hexdigest()

    if not hmac.compare_digest(signature, expected):
        raise HTTPException(status_code=401, detail="Invalid signature")

    # Parse and log the data
    data = await request.json()
    print(f"Received scan: {data}")

    # Here you'd update your inventory system
    # update_inventory(data['data']['sku'], data['data']['intent'])

    return {"status": "received"}

Run it:

uvicorn main:app --reload
# Expose with ngrok if testing locally:
# ngrok http 8000

Step 3: Create a product shortlink with data (1 minute)¶

curl -X POST https://usnp.me/shorten \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "redirect_url": "https://myshop.com/products/widget",
    "data": {
      "sku": "WIDGET-42",
      "campaign": "popup-shop-2026",
      "intent": "purchase"
    },
    "webhooks": ["https://your-webhook-url.com/webhook"]
  }'

Response:

{
  "short_id": "abc123",
  "short_url": "https://usnp.me/abc123",
  "redirect_url": "https://myshop.com/products/widget",
  "data": {"sku": "WIDGET-42", "campaign": "popup-shop-2026", "intent": "purchase"},
  "webhooks": ["https://your-webhook-url.com/webhook"],
  "created_at": "2026-05-13T10:00:00Z"
}

Save the short_url.

Step 4: Generate a QR code (30 seconds)¶

curl -O -J https://usnp.me/abc123/qr?format=png&scale=10&dark=%23000000&light=%23FFFFFF

This downloads abc123.png — a high-quality QR code you can print.

For print materials, use CMYK colors:

curl -O -J https://usnp.me/abc123/qr?format=svg&scale=10&dark=cmyk(100,0,100,0)&light=0,0,0,0

Step 5: Test it (1 minute)¶

Open the QR code image
Scan it with your phone's camera (or visit the short_url in a browser)
You're redirected to the product page
Check your webhook receiver — you should see:

{
  "event": "hit",
  "short_id": "abc123",
  "redirect_url": "https://myshop.com/products/widget",
  "hit_id": "...",
  "hit_at": "2026-05-13T10:05:00Z",
  "data": {
    "sku": "WIDGET-42",
    "campaign": "popup-shop-2026",
    "intent": "purchase"
  }
}

Step 6: Verify the signature (1 minute)¶

In production, always verify the X-Webhook-Signature header:

import hmac
import hashlib

def verify_signature(body: bytes, signature: str, secret: str) -> bool:
    expected = hmac.new(secret.encode(), body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(signature, expected)

The signature proves the payload came from yousnap.me and hasn't been tampered with.

What you just built:¶

A shortlink that carries structured data
A webhook pipeline that receives that data on every scan
A print-ready QR code
Signature verification for security

Next steps: - Add more links for different products - Connect your real inventory system - Track conversion rates by campaign - Set up Slack notifications on high-value scans

Full working code: All examples are on GitHub: github.com/granteagon/usnap.me/examples

Learn more: - API Reference: https://yousnap.me/docs/api-reference/ - Swagger UI: https://usnp.me/docs - Quickstart: https://yousnap.me/docs/quickstart/

6. Pre-Launch Checklist¶

Infrastructure¶

[ ] Landing page live at yousnap.me
[ ] Swagger UI accessible at usnp.me/docs (public, no auth required)
[ ] Developer docs at yousnap.me/docs (deployed, all pages render)
[ ] DNS configured correctly (yousnap.me → landing, usnp.me → API)

API Health¶

[ ] All 5 endpoints working in production (POST /shorten, GET /{short_id}, GET /{short_id}/qr, POST /waitlist, GET /health)
[ ] Rate limiting tested under load (confirm free tier: 10/min, pro tier: 60/min)
[ ] Webhook delivery tested with 3 retries and exponential backoff
[ ] HMAC signature verification working correctly
[ ] QR code generation tested (PNG and SVG, custom colors including CMYK)

Monitoring & Reliability¶

[ ] Sentry monitoring active (error tracking and performance)
[ ] Webhook delivery failures logged to Sentry
[ ] Database connection pooling configured
[ ] Health check endpoint responding in <100ms

Content & Docs¶

[ ] Landing page has clear CTA ("Get Started" / "Get API Key")
[ ] Pricing table accurate (free: 100 links, 1k webhooks; pro: unlimited links, 50k webhooks)
[ ] Developer docs have working code examples (tested in CI)
[ ] Quickstart guide walks through create → click → webhook flow
[ ] API reference includes all endpoints with request/response schemas

[ ] Waitlist endpoint working (POST /waitlist saves email to Supabase)
[ ] Email collection tested (check Supabase waitlist table)
[ ] Auto-reply email configured (optional, "Thanks for signing up, we'll send your key within 24h")
[ ] Manual provisioning process documented for initial users

Example Projects¶

[ ] Example webhook receiver deployed and accessible (FastAPI or Express.js demo)
[ ] Live demo link ready for Show HN post
[ ] Working QR code example available for download
[ ] GitHub examples directory complete (create_link.py, create_link.js, webhook_receiver.py, webhook_receiver.js)

Marketing Assets¶

[ ] Screenshots ready (landing page, Swagger UI, QR code example)
[ ] GIF/video of create → scan → webhook flow (optional but nice)
[ ] Social media preview images configured (og:image for landing page)
[ ] Favicon set on landing page and docs

Launch Day Prep¶

[ ] Rate limits tuned for traffic spike (consider temporary increase)
[ ] Database capacity checked (Supabase free tier limits)
[ ] Error monitoring alerts configured (Slack or email)
[ ] Support email or Discord/Slack community ready
[ ] FAQ prepared for common questions
[ ] Competitive analysis ready ("Why not Bitly/TinyURL?")

Post-Launch¶

[ ] Track signups in Supabase (monitor waitlist table)
[ ] Monitor API usage (check for abuse, high-volume users)
[ ] Respond to HN/Reddit comments within 1 hour
[ ] Collect feedback for roadmap prioritization
[ ] Track conversion to pro tier after launch

Launch Sequence Recommendation¶

Day 1 (Morning): - Post to Hacker News (Show HN) — 9-10am PT for maximum visibility - Share on Twitter/Bluesky thread - Monitor HN comments closely, respond quickly

Day 1 (Afternoon): - Post to r/SideProject and r/webdev - Engage in comments

Day 2: - Post to r/InternetIsBeautiful (check subreddit rules first) - Share on Indie Hackers - Cross-post Twitter thread to Bluesky

Day 3-4: - Publish Dev.to / Hashnode tutorial - Share tutorial on Twitter, Reddit, HN as "tutorial follow-up" - Email waitlist with early access keys (if you have a list)

Week 2: - Retrospective post: "We launched yousnap.me — here's what we learned" - Share metrics (signups, links created, webhook deliveries) - Product Hunt launch (if not done earlier)

Key Messages to Reinforce¶

It's not a URL shortener — it's a webhook trigger with a link attached
Physical-to-digital bridge — QR codes on packaging, flyers, badges
Developer-first — simple API, good docs, signature verification
No infrastructure — you don't need to run a queue or webhook service
Free tier is generous — 100 links and 1k deliveries/month lets you try real use cases

FAQ Prep¶

Q: Why not just use Bitly/TinyURL? A: They track clicks, but they don't let you attach structured data or deliver it via webhooks. You'd need to poll their API or scrape analytics. yousnap.me pushes data to your backend instantly with HMAC signatures.

Q: Can I self-host this? A: Not yet, but I'm considering open-sourcing it if there's demand. For now it's a hosted service.

Q: What happens when I hit my quota? A: Free tier: link creation returns 429 (rate limit exceeded). You can still redirect existing links and generate QR codes. Pro tier has much higher limits.

Q: How reliable are webhook deliveries? A: 3 retries with exponential backoff. Typical success rate is 99%+ if your endpoint is stable. You can check delivery status via GET /{short_id}/webhooks/status.

Q: Do QR codes expire? A: No. Once created, shortlinks and their QR codes work forever (unless you delete them, which isn't implemented yet).

Q: CMYK for print — is it accurate? A: We convert CMYK to RGB using standard formulas for on-screen preview. For print-critical color matching, use your print software's color management. The CMYK input is a convenience, not a replacement for professional prepress.

Q: Can I update the data or webhooks after creating a link? A: Not yet. This is on the roadmap. For now, create a new link if you need to change data/webhooks.

Success Metrics¶

Week 1: - 100+ signups - 50+ active users (created at least one link) - 1,000+ links created - 5,000+ webhook deliveries - 3+ HN upvotes or front page - 10+ positive comments/feedback messages

Month 1: - 500+ signups - 100+ active users - 5+ pro tier conversions - Featured in at least one newsletter or blog

Questions to track: - What use cases are people building? - What's the conversion rate from signup to first link? - What's the drop-off point in the quickstart? - What features are most requested?

Launch Day Support Plan¶

Availability: Be online for 4-6 hours after posting to HN/Reddit to respond to questions.

Common questions to prepare for: - "How is this different from X?" — Have comparison ready - "What's your tech stack?" — FastAPI, Supabase, DigitalOcean - "Is this open source?" — Not yet, but considering it - "Can I see a demo?" — Link to live example - "How do you prevent abuse?" — Rate limiting, API key auth, monitoring

Escalation: If server crashes or rate limits are hit too hard, be ready to: 1. Temporarily increase rate limits in production 2. Scale DigitalOcean app to more instances 3. Add Cloudflare if getting DDoS'd

Keep Sentry dashboard open to catch errors in real-time.

End of Launch Plan

This document provides ready-to-post content for all major developer channels. Adjust tone and emphasis based on each community's culture, but keep the core message consistent: this is about connecting physical events to APIs, not just shortening URLs.

Developer Community Launch Plan¶

Positioning¶

1. Hacker News — Show HN Post¶

2. Reddit Posts¶

r/SideProject¶

r/webdev¶

r/InternetIsBeautiful¶

3. Twitter/Bluesky Thread¶

4. Indie Hackers Post¶

5. Dev.to / Hashnode Tutorial¶

Step 1: Get your API key (30 seconds)¶

Step 2: Set up a webhook receiver (1 minute)¶

Step 3: Create a product shortlink with data (1 minute)¶

Step 4: Generate a QR code (30 seconds)¶

Step 5: Test it (1 minute)¶

Step 6: Verify the signature (1 minute)¶

What you just built:¶

6. Pre-Launch Checklist¶

Infrastructure¶

API Health¶

Monitoring & Reliability¶

Content & Docs¶

Sign-Up & Onboarding¶

Example Projects¶

Marketing Assets¶

Launch Day Prep¶

Post-Launch¶

Launch Sequence Recommendation¶

Key Messages to Reinforce¶

FAQ Prep¶

Success Metrics¶

Launch Day Support Plan¶