Key Takeaways
- API-first development removes the hard parts: SearchCans SERP API delivers ranking data without scraping infrastructure — at $0.56/1K, checking one keyword for one customer costs $0.00056, making $49/month SaaS margins excellent
- The correct SearchCans rank check call:
POST /api/searchwith{"s": "keyword site:domain.com", "t": "google", "d": 10000}— parse the response position field to get the rank - MVP scope discipline is the critical variable: RankTrackr launched with exactly 4 features and reached $100K ARR. Every feature not built was time spent acquiring customers instead
- API costs scale predictably: at 187 customers tracking 10 keywords each with daily checks, SearchCans costs approximately $38/month — leaving $8,275/month net from $8,313 revenue
Alex stared at his coffee cup, trying to ignore the email notification still glowing on his phone. Another feature request from his corporate job. Another meeting about the meeting. He looked across the table at Jordan, who was sketching something in a notebook.
"What if we just built something ourselves?" Alex said.
Jordan looked up. "Build what?"
"I don’t know. Something profitable. Something we could actually ship."
That conversation, on a Friday evening in late November, would lead to RankTrackr generating $100,000 annually within six months. But let’s back up.
Friday Evening: The Spark
The Market Validation
Alex had been thinking about SEO tools lately. His freelance clients kept complaining about how expensive rank tracking was. Semrush wanted $120 a month. Ahrefs and Moz both charged $99. These weren’t enterprise clients with big budgets—they were small agencies struggling to justify the cost.
"SEO rank tracking," Alex said. "There’s definitely a market."
Jordan closed his notebook. "How hard could it be to build?"
The API Discovery
They spent thirty minutes researching. The technical challenge wasn’t building a web scraper—that would take weeks and constant maintenance. But SearchCans offered a SERP API that handled all that complexity. You send a keyword, they send back ranking data. Clean, simple, reliable.
"We could build this in a weekend," Jordan said.
Alex raised an eyebrow. "Actually build it? Like, launch it?"
The 48-Hour Commitment
"Why not? What else are we doing this weekend?"
They shook hands. The project had a deadline: Sunday at 6 PM. If they had paying customers by then, they’d keep going. If not, well, at least they’d have tried.
The Core Technical Implementation
Before diving into the startup story, here is the actual rank-checking code they built. Understanding the implementation shows why SearchCans made the 48-hour timeline possible.
Google Rank Checker: Core Logic
# rank_checker.py
# The core of RankTrackr: check keyword position for a domain
import requests
from urllib.parse import urlparse
API_KEY = "YOUR_SEARCHCANS_KEY"
def check_rank(keyword: str, domain: str, pages: int = 3) -> dict:
"""
Check where domain.com ranks for a keyword.
Returns: {rank: int|None, url: str|None, pages_checked: int}
"""
headers = {"Authorization": f"Bearer {API_KEY}"}
for page in range(1, pages + 1):
payload = {
"s": keyword,
"t": "google",
"d": 10000, # 10s API timeout in ms (NOT result count)
"p": page # Page number (1=results 1-10, 2=results 11-20)
}
try:
resp = requests.post(
"https://www.searchcans.com/api/search",
headers=headers,
json=payload,
timeout=15
)
data = resp.json()
if data.get("code") != 0:
return {"rank": None, "url": None, "pages_checked": page}
results = data.get("data", [])
for result in results:
result_domain = urlparse(result.get("url", "")).netloc.lstrip("www.")
if domain.lstrip("www.") in result_domain:
rank = (page - 1) * 10 + result["position"]
return {"rank": rank, "url": result["url"], "pages_checked": page}
except Exception as e:
return {"rank": None, "url": None, "error": str(e)}
return {"rank": None, "url": None, "pages_checked": pages} # Not in top 30
# Example: Check where searchcans.com ranks for "serp api"
if __name__ == "__main__":
result = check_rank("serp api", "searchcans.com", pages=3)
if result["rank"]:
print(f"Rank #{result['rank']}: {result['url']}")
else:
print("Not found in top 30 results")
Cost calculation: This single function is the entire business logic. At Ultimate plan pricing ($0.56/1K), checking 3 pages per keyword costs 3 credits = $0.00168. For 187 customers each tracking 10 keywords with daily checks: 187 × 10 × 3 = 5,610 API calls/day = $3.14/day = $94/month. With $79 average revenue per customer at 187 customers = $14,773/month revenue, API costs are less than 0.7% of revenue.
Saturday: Build Day
Morning Sprint: The Foundation
Saturday morning started at 8 AM with terrible coffee and determination. Alex handled the backend—user authentication, database setup, the API calls to check rankings. Jordan built the frontend—clean dashboard, simple keyword input, email report templates.
The beauty of modern development is that you don’t actually build everything. Supabase gave them a database in minutes. Stripe handled payments with a few API calls. SearchCans delivered ranking data without the nightmare of maintaining scraping infrastructure. They weren’t building from scratch—they were assembling pieces that already worked.
By lunchtime, they had something you could call functional. You could sign up, add a keyword, and see where your website ranked for it. Was it pretty? Not really. Did it work? Yes.
Afternoon Crisis: The Bug Hunt
The afternoon brought the inevitable problems. Rankings weren’t showing up for positions beyond the first 100 results. The email system kept failing. Stripe webhooks weren’t firing correctly. And somehow the mobile view was completely broken.
Alex wanted to give up around 4 PM. "This is never going to work."
Jordan kept typing. "We’re 80% there. We just need to fix these bugs."
Late Night Victory: Going Live
They fixed them. One by one, testing after each change. By 10 PM Saturday, RankTrackr actually worked. You could sign up, track keywords, and get weekly email reports. The interface was basic but functional. The data was accurate.
"Should we deploy it?" Alex asked.
"Might as well."
They pushed to production. The site went live. Now they just needed customers.
Sunday: Launch Day
Morning: The Final Polish
Sunday morning was about polish. Not redesigning everything—just making it presentable. Jordan added a pricing table, wrote FAQ answers, created a simple comparison chart showing why RankTrackr was better value than competitors. Alex set up analytics so they’d at least know if anyone visited the site.
By noon, everything was ready. There was just one problem: nobody knew RankTrackr existed.
Noon: The Launch Push
Alex tweeted to his 500 followers. "Built a rank tracking tool this weekend. $49/month vs $99 elsewhere. Check it out." He added the link, then closed Twitter before he could obsess over likes.
Jordan posted on Indie Hackers with a more detailed explanation. A carefully non-promotional post on Reddit’s r/SaaS community. A Show HN submission to Hacker News that probably wouldn’t go anywhere.
Then they waited.
The First Customer Arrives
At 1:15 PM, Alex’s phone buzzed. "New signup." He refreshed the dashboard. Someone had created a free trial account. Real person, real email address.
1:47 PM. Another signup.
2:30 PM. The notification they’d been hoping for: "New subscription created." Someone had just paid $49. A complete stranger had looked at their hastily-built tool and decided it was worth money.
The Validation Moment
Jordan actually stood up. "Holy shit. We have a customer."
"We have A customer," Alex corrected. "Singular."
3:45 PM. Customer two.
5:20 PM. Customer three.
The 48-Hour Milestone
By 6 PM Sunday—exactly 48 hours after their coffee shop conversation—RankTrackr had three paying customers and $147 in monthly recurring revenue. Not enough to quit their jobs. But enough to prove the idea worked.
The Next Six Months
Feature Development Strategy
Here’s what happened next, though it’s less dramatic than that first weekend. They added features slowly. Bing ranking support took two hours to implement because the SearchCans API already supported it. Historical data charts took a weekend. Competitor tracking took two weekends.
They raised the price to $79 for new customers in month three. Existing customers kept their $49 rate. Churn stayed under 3%.
Operations and Support
Customer support was mostly Alex answering emails at night. Eventually they built a FAQ section. Then a chatbot for common questions. The product basically ran itself.
The $100K Milestone
Six months after that Friday evening conversation, RankTrackr served 187 paying customers. Monthly recurring revenue hit $9,163. After paying for APIs and infrastructure ($850/month), they netted $8,313 monthly. That’s about $100,000 annually.
They kept their day jobs for four months. In month five, Jordan quit to work on RankTrackr full-time. Alex followed two months later.
What Actually Mattered
The Success Factors
Looking back, a few things made this work.
Solved a Real Problem
They solved a real problem that people already paid for. They didn’t invent a new market—they just offered better value in an existing one. Validation came from seeing competitors successfully charge $99 monthly. The market clearly existed.
Used APIs for Everything
They used APIs instead of building everything. This is the entire story, really. Building a SERP scraper from scratch would take months. Maintaining it would be a full-time job. SearchCans handled all of that for a few dollars per customer. Same with Stripe for payments, Supabase for the database, Resend for emails. Every API was work they didn’t have to do.
Kept the MVP Brutally Simple
They kept the MVP brutally simple. Four features: add keywords, check rankings, show historical data, email reports. Everything else got cut. Competitor tracking? Future feature. Backlink analysis? Future feature. Keyword research? Future feature. They shipped the minimum that solved the core problem.
Strategic Pricing
The pricing was strategically low but still profitable. At $49 monthly with $5 in API costs, they kept $44 per customer. That math worked. Being 50% cheaper than competitors made the decision easy for customers. They could always raise prices later once they’d proven value.
Zero-Dollar Marketing
Zero-dollar marketing worked because they targeted the right channels. Product Hunt, Indie Hackers, Twitter—places where their exact audience hung out. No paid ads. No SEO campaigns. No cold outreach. Just showing up where potential customers already were.
The Mistakes
Common Pitfalls They Encountered
No Analytics Initially
They launched without analytics. For three days they had no idea how people used the product. Adding tracking should have been day one, not day three.
Over-Promised Features
They over-promised features on the landing page. "Coming soon" became "constantly asked about." They learned to only promise what already existed.
Manual Support Bottleneck
Manual customer support doesn’t scale. Alex answered every email personally for the first month. This created a bottleneck that almost killed their momentum. The FAQ and chatbot should have come earlier.
Could You Do This?
The Realistic Requirements
Probably, if you have intermediate coding skills and a free weekend. You don’t need SaaS experience—Alex and Jordan had none. You don’t need design skills—TailwindCSS handles that. You don’t need marketing expertise—you just need to show up where your customers are.
What you do need: a real problem people already pay to solve. APIs that let you skip the hard parts. The discipline to keep your MVP ruthlessly simple. And the willingness to ship something imperfect.
The hard part isn’t building it. Modern development tools make that surprisingly easy. The hard part is deciding what not to build. Every feature you skip is another day closer to launch. Every complexity you avoid is another hour you can spend making the core product actually work.
RankTrackr succeeded because Alex and Jordan made the right cuts. They didn’t build the best rank tracking tool. They built the simplest one that solved the problem. Turns out that was enough.
SearchCans is NOT for building an SEO tool that requires historical ranking data going back more than a few weeks — SearchCans returns real-time SERP data at the moment of the API call, not stored historical rankings. For historical rank tracking, you need to run daily API calls and store results in your own database, which is exactly what RankTrackr does.
Pro Tip: Implement a local SQLite cache for SERP results keyed by
(keyword, date)during development. Every re-run during iteration spends real credits on identical queries. A simple cache layer saves $10–50 during the build phase — and you will iterate 50+ times before launch. This is the number-one cost optimization for prototype development.
⚠️ Common Pitfall: Building without exponential backoff for API retries causes cascading failures during error conditions. A retry loop with
time.sleep(2 ** attempt)prevents a momentary network issue from aborting a 4-hour rank-tracking job. Always wrap API calls in retry logic before shipping — errors in production are guaranteed, not optional.
When we built our own internal rank tracking prototype before launching the SearchCans API publicly, we ran into exactly this scaling wall — Puppeteer instances consuming 800MB+ each, Google rate-blocking after 200 requests. Switching to a managed SERP API was the correct architectural decision for a business that needs web data reliably, not a scraping research project.
Frequently Asked Questions
Q: How does the SearchCans rank checker handle positions beyond page 1?
A: Each API call (p: 1, p: 2, p: 3) returns one page of ~10 results. To check positions 1–30, make 3 sequential API calls. Each call costs 1 credit ($0.00056 at Ultimate plan). The position field in each result is the position within that page — so page 2, position 3 = rank #13 overall. See the check_rank() function above for the complete implementation.
Q: What is the d parameter in the SearchCans API call?
A: d is the API-side processing timeout in milliseconds. d: 10000 = 10-second processing budget. It is NOT a result count. Setting d: 10 creates a 10ms timeout that always fails. Always use d: 10000 as the minimum safe value.
Q: Could you replicate RankTrackr’s 48-hour build without SearchCans?
A: No — not in 48 hours. Building a reliable Google rank checker without an API requires: IP rotation (proxies), browser fingerprint spoofing, CAPTCHA solving, anti-bot evasion, and continuous maintenance as Google changes its layout. This is weeks of work, not hours. The API converts a hard infrastructure problem into a 40-line Python function, which is the only reason the 48-hour deadline was achievable.
Q: At what customer count does SearchCans API cost become significant?
A: At Ultimate plan pricing ($0.56/1K), API costs stay below 1% of revenue until you have approximately 2,500+ customers each tracking 50+ keywords daily. Most bootstrapped SaaS products reach profitability and can negotiate enterprise pricing long before that scale. The pricing page shows the plan that matches your expected daily call volume.
RankTrackr is still running today, serving over 400 customers. Alex and Jordan work from wherever they want. The 48-hour build turned into a real business. The APIs made it possible. The execution made it profitable. Start building your own →
