Perplexity.ai has changed how we use the internet. It’s no longer about “ten blue links”; it’s about getting answers.
Naturally, every developer wants to build their own—whether for a niche vertical (e.g., “Perplexity for Legal”) or just to own their data. The GitHub ecosystem is exploding with templates like nashsu/FreeAskInternet and Vercel AI SDK starters.
But there is a hidden trap: The Cost of Search.
The Problem: High Costs of Search APIs
Most tutorials recommend SerpApi or Bing Web Search API. These are fantastic services, but they are priced for enterprise budgets, not indie hackers. If your app goes viral, your API bill could bankrupt you overnight.
Today, we will build a “Perplexity Clone” that is 95% cheaper than the standard stack, using SearchCans.
The Economics of an Answer Engine
Before we write code, let’s look at the math. An “Answer Engine” typically performs 2-3 searches per user query to ensure coverage.
Cost Comparison: SearchCans vs. Traditional Providers
Here is the cost per 1,000 user queries (assuming 2 searches per query) across major providers:
| Provider | Cost per 1k Searches | Cost per 1k User Queries (2 searches) | Monthly Cost (10k Users) |
|---|---|---|---|
| Bing Search API (S1) | ~$25.00 | $50.00 | $15,000+ |
| SerpApi (Developer) | ~$20.00 | $40.00 | $12,000+ |
| SearchCans (Standard) | $0.90 | $1.80 | $540 |
| SearchCans (Ultra) | $0.56 | $1.12 | $336 |
Data based on 2026 public pricing. SearchCans Ultra plan offers ~3M credits for $1,680.
By switching to SearchCans, you move from “burning VC money” to “profitable on day one.”
The Stack
We will keep it simple. No complex React frontends today—just pure Python power.
Frontend
Streamlit (for rapid UI).
Search
SearchCans SERP API (to find sources).
Reading
SearchCans Reader API (to parse sources into Markdown).
Brain
OpenAI GPT-4o (or any local LLM via Ollama).
Step 1: The Search Function
Why Raw SERP Data Matters
First, we need to fetch live results from Google. Unlike other APIs that charge for metadata you don’t need, SearchCans gives you the raw SERP data instantly.
The Python Implementation
import requests
SEARCHCANS_KEY = "YOUR_KEY"
def search_web(query):
url = "https://www.searchcans.com/api/search"
params = {
"query": query,
"engine": "google",
"time_frame": "y" # Past year for relevance
}
headers = {"Authorization": f"Bearer {SEARCHCANS_KEY}"}
response = requests.get(url, params=params, headers=headers)
return response.json().get("result", {}).get("data", [])
Step 2: The “Reading” Function (The Secret Sauce)
The Challenge of Content Extraction
Perplexity doesn’t just read the title; it reads the content. This is usually the hardest part. You’d normally need Puppeteer, proxies, and a residential IP network to bypass blocks.
How SearchCans Reader API Solves This
SearchCans Reader API handles this for you. It renders the page and returns clean Markdown.
def get_page_content(url):
api_url = "https://www.searchcans.com/api/url"
params = {
"url": url,
"use_browser": "true" # Essential for dynamic JS sites
}
headers = {"Authorization": f"Bearer {SEARCHCANS_KEY}"}
try:
resp = requests.get(api_url, params=params, headers=headers, timeout=10)
return resp.text # Returns Markdown
except:
return ""
Step 3: Putting It Together (Streamlit)
The Answer Engine Flow
Now, we stitch it into a UI. The logic is:
- User inputs a question.
- We search Google.
- We scrape the top 3 results.
- We construct a context prompt for the LLM.
Complete Streamlit Application
import streamlit as st
from openai import OpenAI
st.title("SearchCans Answer Engine ")
user_query = st.text_input("What do you want to know?")
if user_query:
# 1. Search Phase
with st.status("Searching the web..."):
results = search_web(user_query)
top_links = results[:3] # Pick top 3
# 2. Reading Phase
context_text = ""
with st.status("Reading sources..."):
for item in top_links:
st.write(f"Reading: {item['url']}")
content = get_page_content(item['url'])
# Truncate to save tokens, keep first 2000 chars
context_text += f"Source: {item['url']}\nContent: {content[:2000]}\n\n"
# 3. Generation Phase
client = OpenAI(api_key="YOUR_OPENAI_KEY")
prompt = f"""
Answer the question based ONLY on the following context.
Cite sources using [Source URL].
Question: {user_query}
Context:
{context_text}
"""
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": prompt}]
)
st.markdown("### Answer")
st.write(response.choices[0].message.content)
st.markdown("### Sources")
for item in top_links:
st.write(f"- [{item['title']}]({item['url']})")
Why This Matters
Building a Perplexity clone isn’t just a cool weekend project. It’s the foundation of Vertical AI Agents.
The Rise of Vertical AI Agents
Financial Analyst Agent
Search specifically for “Q3 Earnings Reports” (using site:sec.gov filters in SearchCans).
Legal Researcher
Search case law databases.
Travel Planner
Search distinct travel blogs.
The Economics of Deep Research
When your search costs are effectively zero ($0.56/1k is negligible), you can afford to chain multiple searches together to perform “Deep Research” agents that iterate 10+ times on a single problem.
Conclusion
The barrier to entry for building search-based AI apps is no longer technology—it’s cost. By optimizing your stack with SearchCans, you can build tools that compete with the giants without needing their budget.
Grab your API key and start building.
Resources
Related Topics:
- Building Advanced RAG with Real-Time Data - Integrate this with Vector DBs.
- SERP API vs Web Scraping Comparison - Alternative ways to build.
Get Started:
- Free Trial - Get 100 free credits
- API Documentation - Technical reference
- Pricing - Compare our $0.56/1k vs the rest
SearchCans provides real-time data for AI agents. Start building now →