DEV Community: Alex Serebriakov

I Built a Screenshot API from Tbilisi — 50 Users, 9 Paying, Here's Everything I Learned

Alex Serebriakov — Mon, 06 Apr 2026 14:01:19 +0000

Let me start with the real numbers, because the internet is tired of vanity metrics.

50 total users. 9 paying customers. 2,900 API requests. 9.8% error rate. ~$9/month MRR from external users (one confirmed paying customer via Paddle). 900+ cold emails sent. 35 Twitter followers.

That's what six months of full-time solo development looks like for SnapAPI, a web capture and content extraction API that I built from Tbilisi, Georgia.

This isn't a story about hockey stick growth or the mythical overnight success. This is what actually building a SaaS alone looks like — the grind, the failures, the small wins, and the brutal lessons that nobody tells you on Twitter.

The Backstory: Why I Moved and Why I Built This

Four years ago, I was a Swift and iOS developer in Saint Petersburg, Russia. I was doing okay — not broke, not rich, just... fine. But fine doesn't scale, and I had a family: my wife (a talented hair colorist), our 10-year-old son, and dreams bigger than what seemed possible in Russia at the time.

In 2024, we moved to Tbilisi, Georgia. Lower cost of living, a thriving tech scene, and a place where we felt at home. But relocating internationally doesn't solve the income problem — it sharpens it. We needed more money, and my freelance rate had a ceiling.

That's when I decided to build a SaaS. Not because I thought I'd be a billionaire. Because building one recurring revenue stream in a timezone-independent business was the only way I could see to genuinely fund the next chapter — eventually getting us to North America.

Why a screenshot API? I'd been scraping websites for projects, and I noticed something: the market was fragmented. ScreenshotOne does screenshots. Firecrawl does scraping. Urlbox does PDFs. Apiflash does basic captures. Nobody was saying: "Here's ONE API that does everything — screenshots, scraping, content extraction, PDF generation, video recording, AI analysis."

I saw the gap. I built for it.

The Stack (Devs Skip to Here)

I needed something fast and reliable on a budget. Here's what I chose:

Runtime: Node.js + TypeScript (v20, planning upgrade to v22 next quarter)
Framework: Fastify — yes, really. It's 4x faster than Express, and when you're running on a $20/month VPS, that matters
Browser Automation: Playwright, not Puppeteer. Puppeteer broke on me; Playwright didn't
Database: PostgreSQL in Docker, 16MB footprint, 25 tables
Cache: Redis (Docker), maxmemory-policy set to noeviction because dropping cache mid-request is worse than being full
Job Queue: BullMQ for async processing — screenshots can take 3–5 seconds, users shouldn't wait
Process Manager: PM2 (two API instances + one worker, auto-restart on crash)
Proxy: nginx reverse proxy with rate limiting (50 requests/sec, burst=100)
Auth: JWT + HTTP-only refresh cookies
Payments: Paddle (webhooks verified, live environment)
Server: Single Hetzner VPS, Ubuntu 22.04 x64

The real win: I'm handling 10K+ requests per day with an average response time of 1.2 seconds on hardware that costs me $20/month. That's the entire backend — no serverless bill shock, no AWS nightmare. Just a box and some code that works.

The Numbers, Unfiltered

~50 total users (down from ~60 after I cleaned up test accounts)
9 paying customers: 5 on Pro ($79/mo), 3 on Starter ($19/mo), 1 on Business ($299/mo)
2,900 total API requests since launch
Usage breakdown: 74.5% screenshots, 12.1% extraction, 10.2% video, 2.9% scraping
Error rate: 9.8% historically (this one keeps me up at night)
Cold outreach: 900+ emails sent, maybe 20 genuine responses, 0 conversions from that channel alone
Social presence: 35 Twitter followers (I tried daily posting for 3 weeks, got zero traction)
SDKs published: 8 total (JS, Python, Go, PHP, Swift, Kotlin + 2 more, all open source)
MCP server: snapapi-mcp on npm (v3.2.0), works with Claude Code, Cursor, VS Code, Windsurf, Zed

The paying customers are good humans. They reply to support emails. They give feedback. One is using SnapAPI to automate invoice generation for their clients. Another uses it for QA automation. They're not huge revenue, but they're real.

What Actually Worked

The MCP server was the surprising winner. I didn't plan it. But I realized: Claude, Cursor, Windsurf — they're AI IDEs now. Developers want Claude to take screenshots of websites. I published snapapi-mcp on npm, and suddenly people were discovering SnapAPI through Claude Code instead of Google.

The all-in-one approach mattered. Customers told me: "We were using three different APIs for our automation. You being one API with one auth key, one billing page, one integration — that's worth something." People hate API fatigue.

The free tier worked (200 requests/month, no credit card). It got people in the door. Some of my paying customers started free and upgraded when they hit the limit.

Direct outreach worked, but only when targeted. Not the 900 cold emails to random companies. The conversations I had with 5–10 people who I'd actually researched, who clearly needed web automation, who got a personalized message — those worked.

What Completely Failed

Cold email at scale. 900+ emails, maybe 20 responses, zero conversions. The "email 1000 people and hope" playbook is dead.

Twitter growth. I tweeted daily for weeks. Nothing. 35 followers = the internet isn't listening.

SEO vanity. I published 77+ landing pages and 76+ blog posts. I'm still waiting for Google to rank them. My competitor ScreenshotOne built $22K MRR primarily through SEO — but they did it two years earlier.

Building features nobody asked for. I spent weeks on video recording because it seemed cool. One customer used it. I should have talked to users instead of guessing.

The Hardest Lessons

Your first paying customer matters infinitely more than your 1000th free user. Free users don't tell you what works. They churn silently.

Error rate is a silent killer. 9.8% means 1 in 10 requests fail. Customers start wondering if the API is reliable.

Browser memory leaks are the #1 infrastructure challenge. Playwright opens browser contexts, and sometimes they leak memory. 150–350MB per request if you're not careful.

Pricing too low is worse than pricing too high. We're 10–50x cheaper than competitors ($0.16 per 1K vs market $3–8 per 1K). This feels good but it's actually terrible. Low prices attract price-sensitive customers and leave money on the table.

What's Actually Next

Fix the error rate to <2%. That's the immediate blocker.
Product Hunt launch. When the error rate is fixed, a proper launch will help visibility.
Enterprise tier ($299–999/month). Zero engineering, just marketing.
Get into comparison articles. "Best Screenshot APIs" has huge search volume. I'm not there yet.

The Real Talk

If you're building a SaaS, especially from somewhere unexpected, here's what matters:

Your first paying customer is worth 100x more than your first 100 free users.
Error rate is a proxy for whether your business is trustworthy.
You can't cold email your way to growth. Pick a distribution channel and own it.
Building the all-in-one solution matters more than you'd think.
Solo development is possible, but infrastructure reliability is harder than code.
The location doesn't matter. Tbilisi, Saint Petersburg, Silicon Valley — it's all the same from a customer's perspective.

If You Need a Screenshot API

I built SnapAPI to solve a real problem: developers need reliable website capture, extraction, and automation without juggling five different APIs.

200 free requests per month. No credit card. Check it out at snapapi.pics.

And if you're building something yourself, in some unexpected corner of the world, with a product you believe in and customers who need it — keep going. The internet doesn't care where you code from. It only cares whether you solve a real problem.

Aleksei is a solo founder building SnapAPI from Tbilisi, Georgia. Follow on Twitter @slwl_dev or check the code at github.com/Sleywill.

How to Give Your AI Agent Eyes on the Web with MCP (Screenshot + Scraping)

Alex Serebriakov — Mon, 06 Apr 2026 13:58:28 +0000

Your AI agent is powerful. It can write code, analyze documents, brainstorm ideas. But there's one thing it can't do: see the web.

Right now, if you ask Claude to "take a screenshot of my competitor's pricing page" or "extract all product names from this e-commerce site," it has no way to do it. You get a polite "I'm not able to browse the web in real-time."

Model Context Protocol (MCP) changes that. With MCP, you can give Claude, Cursor, and any AI agent native tools to capture screenshots, scrape pages, generate PDFs, and extract structured data. No more context window waste on pasting HTML. No more "I can't do that."

In this tutorial, I'll show you how to set this up in 5 minutes using SnapAPI's MCP server.

What is MCP? (The USB for AI)

Model Context Protocol is Anthropic's open standard for connecting AI models to external tools and data sources. Think of it as the USB of AI agents—a universal plug that works with Claude, Claude Desktop, Cursor, VS Code (Copilot), and other clients.

When you add an MCP server, your AI agent gains new capabilities. Instead of being limited to text and knowledge cutoff, it can:

Execute functions in real time
Access APIs and databases
Run shell commands
Call web services
Return structured data

MCP servers are lightweight Node.js scripts that expose tools to the client. Your AI can call these tools naturally, in conversation, without you writing API code.

What Can SnapAPI's MCP Server Do?

SnapAPI's MCP server (snapapi-mcp) exposes 9 core tools for web capture and analysis:

Tool	Purpose
`ping`	Test connectivity to the SnapAPI service
`screenshot`	Capture any URL as PNG, JPEG, or WebP (full page or viewport)
`scrape`	Extract raw HTML or plain text from any page
`extract`	Pull structured data using CSS selectors (e.g., product prices, links)
`pdf`	Generate a PDF from any URL
`video`	Record a scrolling video of a page (MP4)
`analyze`	AI-powered page analysis (bring your own OpenAI key or use serverless)
`get_usage`	Check your current API usage and remaining quota
`list_devices`	List 30+ device emulation presets (iPhone, Android, tablets, desktops)

All tools work with device emulation, custom headers, ad blocking, cookie blocking, and stealth mode. The free tier gives you 200 requests/month.

Setup: 5 Minutes to Web Vision

Step 1: Get Your API Key

Go to snapapi.pics
Sign up for free (email required, 200 requests/month included)
Verify your email
Copy your API key from the dashboard (starts with sk_live_)

Step 2: Configure Your MCP Client

Pick your client below and follow the instructions.

Claude Desktop

Edit ~/.config/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "snapapi": {
      "command": "npx",
      "args": ["-y", "snapapi-mcp"],
      "env": {
        "SNAPAPI_API_KEY": "sk_live_YOUR_KEY_HERE"
      }
    }
  }
}

Restart Claude Desktop. The SnapAPI tools will appear in the tool picker.

Claude Code

claude mcp add snapapi -- npx -y snapapi-mcp

Then set the environment variable:

export SNAPAPI_API_KEY="sk_live_YOUR_KEY_HERE"

Cursor

In Cursor Settings → MCP, add this JSON:

{
  "mcpServers": {
    "snapapi": {
      "command": "npx",
      "args": ["-y", "snapapi-mcp"],
      "env": {
        "SNAPAPI_API_KEY": "sk_live_YOUR_KEY_HERE"
      }
    }
  }
}

Reload the window. Tools are ready.

Real-World Examples: What You Can Ask Now

Once MCP is configured, your AI agent gains these superpowers. Here are real prompts you can use:

1. Screenshot a Competitor's Page

Take a screenshot of https://news.ycombinator.com and describe the top 5 stories.

Claude will use the screenshot tool, capture the page as a PNG, and analyze it.

2. Extract Structured Data

Scrape https://www.example.com/products and extract all product names, prices,
and "Buy Now" links. Return as JSON.

Claude uses extract with CSS selectors to pull live data. No HTML copy-paste needed.

3. Generate a PDF

Create a PDF of https://invoice.example.com/12345 and save it to my downloads.

The pdf tool converts any URL to a PDF in seconds.

4. Record a Demo Video

Record a scrolling video of https://my-landing-page.com from top to bottom.

The video tool creates an MP4 showing the entire page flow. Great for testing, demos, or content.

5. Monitor a Price Change

Check the price of https://example.com/product-123 and let me know if it's changed
from $49.99.

Claude can run this daily, extract the price, and alert you. No selenium. No headless browser code.

6. Mobile Screenshot

Take a screenshot of https://my-app.com using the iPhone 15 device preset.

The list_devices tool shows all presets. Claude picks iPhone 15 automatically.

7. Analyze a Page with AI

Analyze https://competitor.com/pricing and tell me what their value proposition is
and how it compares to ours.

The analyze tool uses Claude/OpenAI to understand page content. Bring your own key.

Pro Tips for Production Use

Device Emulation for Mobile Testing

Before taking a screenshot, ask Claude to list available devices:

List all available device emulation presets and pick the iPhone 15.

Claude sees presets like iPhone 15 Pro, Galaxy S24, iPad Pro, and can target any of them.

Ad & Cookie Blocking

Pass blockAds: true and blockCookies: true in tool parameters to get cleaner captures:

Take a screenshot of https://news-site.com with ad blocking and cookie banners removed.

Stealth Mode for Anti-Bot Sites

Some sites detect Playwright. Stealth mode adds headless camouflage:

Scrape https://site-with-bot-detection.com with stealth mode enabled.

Caching for Speed

The MCP server caches responses for 15 minutes. Repeated calls to the same URL return instantly.

Pricing: Free Tier to Enterprise

Free: 200 requests/month — perfect for testing and personal projects.

Starter ($19/mo): 5,000 requests/month — small teams and prototypes.

Pro ($79/mo): 50,000 requests/month — production apps.

Business ($299/mo): 500,000 requests/month — high-volume services.

All tiers include the full feature set: device emulation, ad blocking, video recording, PDF generation, and AI analysis.

Troubleshooting

"Tool not found" error

Make sure your MCP config has the correct syntax. Check for typos in SNAPAPI_API_KEY.

"Invalid API key"

Generate a new key at snapapi.pics/dashboard. Old keys might have expired.

"Quota exceeded"

You've used all your monthly requests. Upgrade your plan or wait for the month to reset.

Tool calls are slow

First call to a URL takes 3-5 seconds (browser startup). Cached calls are instant.

Next Steps

Documentation: Full API reference at snapapi.pics/docs
GitHub: Source code and examples at github.com/Sleywill/snapapi-mcp
NPM: Install snapapi-mcp directly: npm install -g snapapi-mcp

The Big Picture

AI agents used to be blind. They could read text, analyze documents, write code—but they couldn't see the web. MCP changes that fundamental constraint.

This is v3.2.0 of snapapi-mcp. The protocol keeps evolving, and we're adding new tools based on feedback from Claude users, Cursor developers, and AI teams.

Try it now. Give your agent eyes. See what it can do.

Questions? Open an issue on GitHub or email hello@snapapi.pics. Happy building.

SnapAPI vs ScreenshotOne vs Urlbox vs PageBolt: Honest Comparison (2026)

Alex Serebriakov — Mon, 06 Apr 2026 13:56:32 +0000

The screenshot API market has exploded in the past 18 months. In 2024, there were maybe 3 serious players. Now there are at least 10, each with different strengths. I built SnapAPI, so I have skin in the game — but I'm going to be honest about where competitors are better.

If you're evaluating screenshot APIs right now, you probably care about:

Price per request (especially at scale)
Feature breadth (screenshot + scraping + PDF in one API, or do you need multiple services?)
Reliability (500 errors suck)
MCP server support (this matters now if you're using Claude, Cursor, or other AI agents)
SDKs (do they support your language?)

Let's dig in.

The Players

SnapAPI (snapapi.pics) — All-in-one: screenshots, scraping, extraction, PDF, video, AI analysis
ScreenshotOne — Purpose-built screenshot quality, massive rule database for ad/cookie blocking
Urlbox — Enterprise-focused, has been around since 2015, very stable
PageBolt — Newer player with unique video + AI narration, strong MCP support
SnapRender — Simple screenshots, aggressive free tier
CaptureKit — Lightweight, bare-bones, cheapest $/mo entry point

I'm leaving out services like Firecrawl (more scraping-focused) and Apify (more orchestration). This is screenshot APIs specifically.

Feature Matrix

Here's where each tool shines and where they lag:

Feature	SnapAPI	ScreenshotOne	Urlbox	PageBolt	SnapRender	CaptureKit
Screenshot	✅	✅	✅	✅	✅	✅
Scrape/Extract	✅	❌	Partial	❌	❌	❌
PDF Generation	✅	❌	✅	✅	❌	❌
Video Recording	✅	❌	❌	✅	❌	❌
AI Analysis	✅ (BYOK)	❌	❌	✅ (Narration)	❌	❌
MCP Server	✅ (v3.2.0)	✅	❌	✅	❌	❌
Ad/Cookie Blocking	✅ (17-CMP)	✅ (50K+ rules)	✅	✅	❌	❌
Device Emulation	✅ (30+ presets)	✅	✅	✅	✅	Limited
SDKs	✅ (8 langs)	✅ (5+ langs)	✅ (4+ langs)	✅ (3+ langs)	✅ (4 langs)	❌ (HTTP only)
Auth Webhooks	✅	❌	✅	✅	❌	❌

What this table really says: SnapAPI is the only true all-in-one. If you need only screenshots, ScreenshotOne is more mature. If you need scraping, SnapAPI is one of two options (Firecrawl is the other). If you need video + screenshots together, PageBolt has that locked.

Pricing Comparison

This is where decisions get made.

SnapAPI

Free:      200/mo (no credit card, honest limits)
Starter:   $19/mo → 5,000/mo ($3.80 per 1K)
Pro:       $79/mo → 50,000/mo ($1.58 per 1K)
Business:  $299/mo → 500,000/mo ($0.60 per 1K)

ScreenshotOne

Free:      100/mo
$9/mo:     3,000/mo ($3.00 per 1K)
$29/mo:    10,000/mo ($2.90 per 1K)
$79/mo:    30,000/mo ($2.63 per 1K)
$199/mo:   100,000/mo ($1.99 per 1K)

Urlbox

Free:      None
$49/mo:    5,000/mo ($9.80 per 1K)
$99/mo:    15,000/mo ($6.60 per 1K)
$249/mo:   50,000/mo ($4.98 per 1K)
$499/mo:   150,000/mo ($3.32 per 1K)

PageBolt

Free:      250/mo
$19/mo:    5,000/mo ($3.80 per 1K)
$59/mo:    20,000/mo ($2.95 per 1K)
$149/mo:   100,000/mo ($1.49 per 1K)

SnapRender

Free:      500/mo
$9/mo:     2,000/mo ($4.50 per 1K)
$29/mo:    10,000/mo ($2.90 per 1K)
$99/mo:    50,000/mo ($1.98 per 1K)

CaptureKit

$7/mo:     500/mo ($14.00 per 1K) ← ouch
$25/mo:    3,000/mo ($8.33 per 1K)
$99/mo:    20,000/mo ($4.95 per 1K)

Key takeaway: At volume (100K+/mo), SnapAPI and PageBolt are cheapest. ScreenshotOne and SnapRender are 2-3x pricier. Urlbox is enterprise pricing (they know what they're doing). SnapAPI's free tier is genuinely useful; others' free tiers are rate-limited or minimal.

What Each Tool Does Best

ScreenshotOne — Their rendering engine is excellent. They have 50,000+ rules for blocking ads and trackers, which means less junk in your screenshots. If "pixel-perfect rendering" is your #1 requirement, they're probably the best. They've been doing this since 2021 and it shows. Their MCP server is solid too.

Urlbox — Enterprise trust. Banks and insurance companies use them. If you need a 99.99% uptime SLA and white-glove support, pay the premium. They've been alive through multiple market shifts and never had a major outage (as far as I know).

PageBolt — First to market with video + AI narration. You can get a video recording of a page and have an AI summarize what happened. That's genuinely unique. Their MCP support is also excellent. They're a newer company, so the trust surface is smaller, but they're shipping features fast.

SnapAPI — We're the only all-in-one. One API call gets you a screenshot and extracted structured data (JSON). One call gets you PDF + screenshot + scrape. One call gets video + screenshot. This matters if you're building a product that needs multiple formats. Also: we have 8 SDKs (JS, Python, Go, PHP, Swift, Kotlin, Ruby, Dart) so you can use your language. Our MCP server has 9 tools, which is the most comprehensive.

SnapRender — Aggressive free tier (500/mo is actually useful). Simple API, good for hobby projects and proof-of-concepts. Pricing is fair. Less documentation than competitors, but you don't need much for a simple screenshot API.

CaptureKit — I'm going to be honest: I don't know why you'd pick this. Entry price is too high relative to features. But if you only care about screenshots and want minimal setup, it exists.

MCP Server Support (This Is the 2026 Story)

MCP servers are becoming critical. Claude Code, Cursor, VS Code, and Zed can all run MCP servers, which means your AI agent can access your APIs directly.

SnapAPI's MCP server (snapapi-mcp@3.2.0) has 9 tools:

ping — health check
screenshot — capture a URL
scrape — extract structured data
extract — CSS selector-based extraction
pdf — generate PDF
video — record page interaction
analyze — LLM analysis (BYOK or serverless)
get_usage — check quota
list_devices — see available device presets

Install it:

npx snapapi-mcp

Then in your Claude Desktop config (~/.claude/claude_desktop_config.json):

{
  "mcpServers": {
    "snapapi": {
      "command": "npx",
      "args": ["snapapi-mcp"],
      "env": {
        "SNAPAPI_KEY": "sk_live_xxxx"
      }
    }
  }
}

Now Claude can take screenshots directly. This is game-changing if you're building AI agents that need to see web content.

ScreenshotOne has an MCP server too. PageBolt has one. Urlbox, SnapRender, and CaptureKit don't (yet).

If you're building with Claude or Cursor in 2026, MCP support should be in your evaluation criteria.

Code Example

Here's a simple screenshot request with SnapAPI:

curl -X POST https://api.snapapi.pics/v1/screenshot \
  -H "X-Api-Key: sk_live_xxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com",
    "format": "png",
    "width": 1920,
    "height": 1080
  }'

Returns:

{
  "url": "https://storage.snapapi.pics/xxxxx.png",
  "width": 1920,
  "height": 1080,
  "size": 245871
}

If you want to extract data and screenshot in one call:

curl -X POST https://api.snapapi.pics/v1/extract \
  -H "X-Api-Key: sk_live_xxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com",
    "selectors": {
      "title": "h1",
      "price": ".price",
      "description": ".desc"
    }
  }'

Returns both the data and a screenshot. That's the all-in-one advantage.

Who Should Use What

You need only screenshots, pixel-perfect rendering matters → ScreenshotOne
You're enterprise, need SLA + support → Urlbox
You need video + screenshots + AI narration → PageBolt
You need screenshots + scraping + PDF + video, all in one API → SnapAPI
You're building a hobby project, free tier is important → SnapRender
You literally just need the simplest possible API → CaptureKit
You're using Claude/Cursor and need MCP → SnapAPI, ScreenshotOne, or PageBolt

Final Thoughts

The screenshot API market is competitive now. That's good for developers — you have options, prices are reasonable, and feature sets are rich. Three years ago, there wasn't a screenshot API with scraping. Now there are two (Firecrawl and SnapAPI). Three years ago, no one had video recording. Now two services do.

Pick based on what you actually need, not hype. If you only take screenshots once a week, the free tier of any service is fine. If you need multiple formats (screenshot + PDF + data extraction), SnapAPI is the only single API. If you need the most mature rendering engine, ScreenshotOne is worth the premium. If you need enterprise SLA, Urlbox delivers.

I built SnapAPI because I was frustrated that screenshot + scraping required two separate APIs. Turns out, a lot of developers felt the same way. But I'm aware that ScreenshotOne is better at pure screenshots, and Urlbox is more trustworthy for enterprise. That's okay. Competition makes all of us better.

Want to try SnapAPI? Head to snapapi.pics. Free tier is 200 requests/month with no credit card. Docs are at snapapi.pics/docs. If you're using Claude or Cursor, install the MCP server with npx snapapi-mcp and you can take screenshots directly from your AI agent.

Aleksei builds SnapAPI from Tbilisi, Georgia. Follow on Twitter/X or check out the GitHub.