DEV Community: Joffy122

How to build a news aggregator with a cheap search API

Joffy122 — Mon, 08 Jun 2026 19:49:36 +0000

In today's fast-paced digital world, staying updated with the latest news is more important than ever. Whether you are building a personal dashboard, a niche curation site, or a feature for your SaaS, a news aggregator is an incredibly useful tool.

However, if you have ever tried to build one using mainstream search APIs like Google Search API or SerpAPI, you have probably run into a major roadblock: cost. These services can easily cost hundreds of dollars a month, which is a massive barrier for indie hackers, hobbyists, and developers working on side projects.

Fortunately, there is a highly affordable alternative. In this tutorial, we will build a fully functional, real-time news aggregator using the Search API (available at api.joffstrends.co.uk for just £9.99/month). This API provides fast, reliable search results without breaking the bank.

By the end of this guide, you will have a clean, responsive web application that fetches live news headlines, filters them by topic, and displays them beautifully.

Prerequisites

To follow along with this tutorial, you will need:

A basic understanding of HTML, CSS, and modern JavaScript (ES6+).
A text editor (like VS Code).
Access to the Search API at https://api.joffstrends.co.uk.

Step 1: Setting Up the HTML Structure

First, let's create our basic HTML skeleton. We need a header, a navigation bar with topic filters, and a container where our news articles will be dynamically injected.

Create an index.html file and add the following code:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>IndieNews - Cheap & Fast News Aggregator</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
    <header>
        <h1>IndieNews</h1>
        <p>Real-time news powered by a budget-friendly Search API</p>
    </header>

    <nav class="filters">
        <button class="filter-btn active" data-topic="latest news">All News</button>
        <button class="filter-btn" data-topic="technology trends">Technology</button>
        <button class="filter-btn" data-topic="finance business">Finance</button>
        <button class="filter-btn" data-topic="sports news">Sports</button>
    </nav>

    <main>
        <div id="loading" class="loading">Fetching the latest headlines...</div>
        <div id="news-container" class="news-grid"></div>
    </main>

    <footer>
        <p>Powered by <a href="https://api.joffstrends.co.uk" target="_blank">JoffsTrends Search API</a></p>
    </footer>

    <script src="app.js"></script>
</body>
</html>

Step 2: Styling the Aggregator

Next, let's add some clean, modern CSS to make our aggregator look professional. Create a style.css file:

:root {
    --primary-color: #2563eb;
    --background-color: #f8fafc;
    --card-background: #ffffff;
    --text-color: #1e293b;
    --text-muted: #64748b;
}

body {
    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
    background-color: var(--background-color);
    color: var(--text-color);
    margin: 0;
    padding: 0;
    line-height: 1.5;
}

header {
    text-align: center;
    padding: 2rem 1rem;
    background: linear-gradient(135deg, #1e3a8a, #2563eb);
    color: white;
}

header h1 {
    margin: 0;
    font-size: 2.5rem;
}

.filters {
    display: flex;
    justify-content: center;
    gap: 1rem;
    padding: 1rem;
    background: white;
    box-shadow: 0 1px 3px rgba(0,0,0,0.1);
}

.filter-btn {
    background: none;
    border: 1px solid #cbd5e1;
    padding: 0.5rem 1rem;
    border-radius: 20px;
    cursor: pointer;
    font-weight: 500;
    transition: all 0.2s;
}

.filter-btn:hover, .filter-btn.active {
    background-color: var(--primary-color);
    color: white;
    border-color: var(--primary-color);
}

main {
    max-width: 1200px;
    margin: 2rem auto;
    padding: 0 1rem;
}

.news-grid {
    display: grid;
    grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
    gap: 2rem;
}

.news-card {
    background: var(--card-background);
    border-radius: 8px;
    overflow: hidden;
    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
    transition: transform 0.2s;
}

.news-card:hover {
    transform: translateY(-4px);
}

.news-content {
    padding: 1.5rem;
}

.news-title {
    font-size: 1.25rem;
    margin-top: 0;
    margin-bottom: 0.5rem;
}

.news-title a {
    color: var(--text-color);
    text-decoration: none;
}

.news-title a:hover {
    color: var(--primary-color);
}

.news-snippet {
    color: var(--text-muted);
    font-size: 0.95rem;
    margin-bottom: 1rem;
}

.news-meta {
    font-size: 0.8rem;
    color: var(--text-muted);
}

.loading {
    text-align: center;
    font-size: 1.2rem;
    color: var(--text-muted);
    padding: 3rem;
}

Step 3: Fetching Data from the Search API

Now, let's write the core logic in app.js. We will fetch search results from the Search API endpoint. The API returns a list of search results, which we will parse and display as news articles.

Create app.js and add the following code:

const API_URL = 'https://api.joffstrends.co.uk/search';
const newsContainer = document.getElementById('news-container');
const loadingElement = document.getElementById('loading');
const filterButtons = document.querySelectorAll('.filter-btn');

// Fetch news from the budget-friendly Search API
async function fetchNews(query) {
    showLoading(true);
    try {
        // We pass the query parameter to get relevant news articles
        const response = await fetch(`${API_URL}?q=${encodeURIComponent(query)}`);

        if (!response.ok) {
            throw new Error('Network response was not ok');
        }

        const data = await response.json();
        displayNews(data.results || []);
    } catch (error) {
        console.error('Error fetching news:', error);
        newsContainer.innerHTML = `<p class="error">Failed to load news. Please try again later.</p>`;
    } finally {
        showLoading(false);
    }
}

// Render the news cards dynamically
function displayNews(articles) {
    newsContainer.innerHTML = '';

    if (articles.length === 0) {
        newsContainer.innerHTML = '<p>No news found for this topic.</p>';
        return;
    }

    articles.forEach(article => {
        const card = document.createElement('article');
        card.className = 'news-card';

        // Extracting standard search result fields
        const title = article.title || 'No Title Available';
        const link = article.link || '#';
        const snippet = article.snippet || 'No description available for this article.';
        const source = article.source || 'Web';

        card.innerHTML = `
            <div class="news-content">
                <h3 class="news-title">
                    <a href="${link}" target="_blank" rel="noopener noreferrer">${title}</a>
                </h3>
                <p class="news-snippet">${snippet}</p>
                <div class="news-meta">
                    <span>Source: ${source}</span>
                </div>
            </div>
        `;
        newsContainer.appendChild(card);
    });
}

function showLoading(isLoading) {
    if (isLoading) {
        loadingElement.style.display = 'block';
        newsContainer.style.display = 'none';
    } else {
        loadingElement.style.display = 'none';
        newsContainer.style.display = 'grid';
    }
}

// Setup event listeners for filtering by topic
filterButtons.forEach(button => {
    button.addEventListener('click', (e) => {
        // Remove active class from all buttons
        filterButtons.forEach(btn => btn.classList.remove('active'));
        // Add active class to clicked button
        e.target.classList.add('active');

        // Fetch news for the selected topic
        const topic = e.target.getAttribute('data-topic');
        fetchNews(topic);
    });
});

// Initial fetch on page load
document.addEventListener('DOMContentLoaded', () => {
    fetchNews('latest news');
});

Why This Search API is a Game Changer

When building aggregators, standard news APIs often restrict you to specific pre-approved news sources or charge exorbitant rates for real-time web searches.

By using the JoffsTrends Search API, you get:

Unbeatable Pricing: At just £9.99/month, it is a fraction of the cost of SerpAPI or Google Custom Search.
Flexibility: You can query any topic, keyword, or niche, and get up-to-date web results instantly.
Simplicity: A straightforward JSON response that is easy to integrate into any frontend or backend stack.

Next Steps to Enhance Your Aggregator

Now that you have a working prototype, here are a few ideas to take it to the next level:

Add Search Functionality: Add a search bar so users can input custom queries.
Implement Caching: Cache results in localStorage or on a simple backend to reduce API calls and improve load times.
Bookmark Feature: Allow users to save articles to read later using browser storage.

Building projects doesn't have to be expensive. With the right budget-friendly tools, you can build powerful, production-ready applications without the high overhead. Happy coding!

I replaced SerpAPI with a £9.99/month alternative — here's how

Joffy122 — Mon, 08 Jun 2026 18:46:49 +0000

As an indie hacker, every dollar (or pound) counts. When you are building a side project, a SaaS MVP, or a simple internal tool, you often need access to search engine results. Whether it's for monitoring brand mentions, gathering training data, or building a custom search interface, web search is a fundamental building block.

For a long time, the default choice for developers has been SerpAPI. It is reliable, well-documented, and widely supported. But as my project began to scale, I hit a major roadblock: the pricing.

The Pricing Pain of SerpAPI

SerpAPI's pricing model is structured around search volume. While they offer a free tier, it is extremely limited (only 100 searches per month). Once you move past that, the costs escalate rapidly:

Developer Plan: $50/month for 5,000 searches.
Production Plan: $130/month for 15,000 searches.

For a bootstrapped project generating $0 in revenue, paying $50 to $130 every single month just to fetch search results is a massive burden. If your app has a spike in traffic or a rogue loop in your development environment, you can burn through your quota in hours and face hefty overage charges.

I needed a solution that was predictable, affordable, and didn't compromise on speed or reliability. I didn't need complex geo-targeting or highly specialized parsing for every obscure search engine feature; I just needed clean, fast, structured web search results.

Discovering the £9.99/month Alternative

After searching for alternatives, I came across the Search API hosted at https://api.joffstrends.co.uk. It offered a flat-rate subscription of just £9.99/month on Gumroad.

Unlike other services that meter every single request and charge you based on complex tiers, this API provided a straightforward, budget-friendly entry point for indie developers. It was exactly what I was looking for: a predictable monthly cost that allowed me to build and test without constantly checking a usage dashboard.

Making the Switch: Code Changes Required

One of my biggest worries when switching APIs is the refactoring overhead. Fortunately, transitioning from SerpAPI to the Search API at api.joffstrends.co.uk was incredibly straightforward.

Here is how my original integration looked with SerpAPI in Node.js:

const SerpApi = require('google-search-results-node');
const search = new SerpApi.GoogleSearch("YOUR_SERPAPI_API_KEY");

const params = {
  q: "indie hackers alternative search api",
  hl: "en",
  gl: "us"
};

search.json(params, (data) => {
  const results = data.organic_results;
  results.forEach(result => {
    console.log(`${result.title} - ${result.link}`);
  });
});

And here is the refactored code using the new Search API. Because it uses a standard REST interface, I didn't even need an external SDK—just a simple fetch call:

const apiKey = "YOUR_SEARCH_API_KEY";
const query = encodeURIComponent("indie hackers alternative search api");
const url = `https://api.joffstrends.co.uk/search?q=${query}&key=${apiKey}`;

async function getSearchResults() {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data = await response.json();

    // The API returns a clean array of organic results
    const results = data.results; 
    results.forEach(result => {
      console.log(`${result.title} - ${result.url}`);
    });
  } catch (error) {
    console.error("Failed to fetch search results:", error);
  }
}

getSearchResults();

The code is actually cleaner. I removed a heavy external dependency (google-search-results-node) and replaced it with native fetch calls, which reduces my bundle size and makes deployment simpler.

The Outcome

The results have been fantastic.

Cost Savings: I went from a potential $50+/month bill to a flat £9.99/month. That is an immediate 80% reduction in my search infrastructure costs.
Predictability: I no longer have anxiety about hitting rate limits or incurring unexpected overage charges during testing.
Performance: Response times are fast and reliable, easily meeting the needs of my application.
Simplicity: The JSON payload returned by api.joffstrends.co.uk is clean and easy to parse, without the unnecessary bloat of dozens of metadata fields I wasn't using anyway.

If you are an indie hacker or a developer building a side project, stop overpaying for search infrastructure. Check out the Search API at api.joffstrends.co.uk and see how much you can save.

How to add web search to your app without breaking the bank

Joffy122 — Mon, 08 Jun 2026 18:37:24 +0000

How to add web search to your app without breaking the bank

In today's digital landscape, users expect instant access to information. Whether you are building a curated directory, a personalized news aggregator, a research assistant, or an AI-powered chatbot, integrating real-time web search can instantly elevate your application from a static tool to a dynamic powerhouse.

However, for indie hackers, hobbyists, and early-stage startups, a major roadblock quickly appears: the exorbitant cost of search infrastructure. In this guide, we will break down what a search API is, why the major players are so expensive, and how you can integrate web search into your application for just £9.99/month using under 20 lines of JavaScript.

What is a Search API?

At its core, a Search API (Application Programming Interface) is a bridge between your application and the vast expanse of the internet. Instead of building your own web crawlers, indexing billions of web pages, and maintaining complex search algorithms—which would cost thousands of dollars a month in server infrastructure alone—you query a Search API.

When your application sends a search term (like "best JavaScript frameworks in 2026") to the API, the service queries its index or scrapes search engine results in real-time. It then returns structured data, typically in JSON format, containing page titles, URLs, snippets, and sometimes images. Your application can then parse this data and display it beautifully to your users.

The Cost Problem: Why Big Providers Break the Bank

If you look at the industry giants, the pricing models are often designed for enterprise budgets, not solo developers.

Google Custom Search JSON API: While they offer a small free tier, once you scale, it costs $5 per 1,000 queries. If your app gets modest traction and performs 10,000 searches a day, you are looking at $50 a day—or $1,500 a month!
Microsoft Bing Search API: Bing's pricing is similarly restrictive, with tiered pricing that quickly scales into hundreds or thousands of dollars as your call volume increases.
SerpApi and other scrapers: While these services are excellent for scraping Google results, their entry-level plans often start at $50 to $100 per month for a very limited number of searches, making them highly impractical for validation phases or side projects.

For a developer trying to validate a new idea, paying $50+ a month just to let users search the web is a massive barrier to entry. This is why budget-friendly alternatives are crucial for the developer ecosystem.

Introducing a Budget-Friendly Alternative

To solve this exact problem, the Search API hosted at https://api.joffstrends.co.uk offers a straightforward, reliable, and incredibly affordable alternative. For a flat rate of just £9.99/month (available via Gumroad), you get access to robust web search capabilities without worrying about complex tier structures or sudden overage bills.

It is designed specifically for indie hackers, beginners, and developers who want to build and ship fast without financial anxiety.

Get Started in Under 20 Lines of Code

Let's look at how simple it is to integrate this Search API into a Node.js application. We will use the native fetch API (available in modern Node.js environments) to make a request and log the results.

Here is the complete implementation in just 13 lines of code:

const apiKey = 'YOUR_API_KEY'; // Replace with your actual API key
const query = encodeURIComponent('indie hacking tools');
const url = `https://api.joffstrends.co.uk/search?q=${query}`;

async function searchWeb() {
  try {
    const response = await fetch(url, { headers: { 'Authorization': `Bearer ${apiKey}` } });
    const data = await response.json();
    data.results.forEach(result => console.log(`- ${result.title}: ${result.url}`));
  } catch (error) {
    console.error('Error fetching search results:', error);
  }
}

searchWeb();

How it works:

URL Construction: We define our target endpoint and safely encode our search query to handle spaces and special characters.
Authorization: We pass our API key securely in the headers.
Fetch & Parse: We make an asynchronous HTTP GET request, parse the JSON response, and iterate through the results array to display titles and URLs.

This lightweight approach keeps your codebase clean, dependencies minimal, and performance high.

Conclusion

You don't need an enterprise budget to build search-enabled applications. By leveraging cost-effective APIs like the one at api.joffstrends.co.uk, you can focus on what truly matters: building a great user experience and finding product-market fit.

Stop overpaying for search infrastructure. Grab your API key, drop those 13 lines of code into your project, and start building today!

Stop Overpaying for Search APIs: A £9.99/month Alternative for Indie Hackers

Joffy122 — Mon, 08 Jun 2026 13:30:14 +0000

Stop Overpaying for Search APIs: A £9.99/month Alternative for Indie Hackers

As an indie hacker or solo developer, every dollar (or pound) counts. When you are building a side project, a directory, an AI-powered curation tool, or a simple monitoring dashboard, you often need web search capabilities. Naturally, you look at the industry standards: SerpAPI, Google Custom Search JSON API, or Bing Web Search.

But then you look at the pricing, and reality hits.

SerpAPI is fantastic, but its entry-level plan starts at $50/month for a limited number of searches. Google Custom Search API gives you 100 free queries per day, but after that, it's $5 per 1,000 queries, and configuring it to search the entire web rather than a specific set of sites is notoriously painful. If your app gets even a modest amount of traffic or needs to perform background scraping/indexing, your hobby budget is instantly blown.

That is why we built the Rook AI Search API (https://api.joffstrends.co.uk). For just £9.99/month, you get a fast, reliable, and dead-simple web search API designed specifically for indie developers who need to ship fast without worrying about massive API bills.

In this article, we will compare the Search API with industry giants, look at how easy it is to integrate, and explore real-world use cases where you can use it to power your next project.

The Pricing Showdown: SerpAPI vs. Google CSE vs. Rook Search API

Let's break down the numbers. If you are running a small SaaS or a side project, how much will search actually cost you?

Feature / Provider	SerpAPI	Google Custom Search	Rook Search API
Starting Price	$50 / month	Free up to 100/day, then $5/1k	£9.99 / month
Setup Complexity	Medium (requires managing engines)	High (requires GCP Console & CSE ID)	Extremely Low (Single API Key)
Target Audience	Enterprise / SEO Professionals	General Developers	Indie Hackers & Bootstrappers
Web-wide Search	Yes	Hard to configure globally	Yes (Default)

With the Rook Search API, you don't have to worry about complex tier structures or sudden overage bills that drain your card overnight. For £9.99/month, you get a predictable, flat-rate service that lets you focus on building your product rather than optimizing your API usage.

Ease of Use: Zero Boilerplate Integration

One of the biggest pain points with Google Custom Search is the setup. You have to create a Google Cloud Project, enable the Custom Search API, create a Custom Search Engine (CSE) in a separate dashboard, configure it to search the entire web (which requires toggling obscure settings), and then manage two different credentials (API Key and CX ID) in your code.

With the Rook Search API, we wanted to make integration as close to a single line of code as possible. Here is how you can perform a web search in Node.js / JavaScript in under 10 lines of code:

const axios = require('axios');

async function searchWeb(query) {
  try {
    const response = await axios.get('https://api.joffstrends.co.uk/search', {
      params: { q: query },
      headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
    });

    console.log('Search Results:', response.data);
  } catch (error) {
    console.error('Error fetching search results:', error.message);
  }
}

searchWeb('indie hackers profitable micro-saas');

No complex SDKs, no multi-step authentication flows. Just a clean, standard REST endpoint that returns structured JSON containing titles, URLs, and snippets of the top web results.

Real-World Use Cases for Indie Hackers

What can you actually build with an affordable, unrestricted search API? Here are three ideas you can build and launch this weekend:

1. AI-Powered Newsletter Curation

AI newsletters are booming, but finding fresh content manually every week is exhausting. You can write a simple cron job that searches the web for terms like "new open source developer tools" or "indie hacker launches" using the Rook Search API, feeds the snippets into an LLM (like Ollama or GPT-4o-mini) to summarize them, and automatically drafts your weekly newsletter.

2. Competitor Monitoring Dashboard

Build a micro-SaaS that monitors mentions of your customers' competitors across the web. By querying their brand names daily, you can identify new blog posts, forum discussions, or press releases, and send your users a daily digest of what their competitors are up to.

3. Niche Directory Aggregator

Directories (e.g., "AI tools for designers", "No-code templates for real estate") are great SEO magnets. Instead of manually searching for new tools to add, use the Search API to scan the web for specific footprints, extract the metadata, and automatically populate your directory database for manual review.

Conclusion: Build More, Spend Less

As developers, we love to build. But too often, we let high API costs kill our projects before they even have a chance to find their first customer.

The Rook Search API is our contribution to the indie hacker ecosystem. We want to make web search accessible to everyone, not just venture-backed startups with deep pockets.

Ready to get started? Head over to api.joffstrends.co.uk and grab your API key today for just £9.99/month. Let's build something amazing together!

hello everyone! does anyone have any idea on how to crack the guns of glory game, im building a bot and really struggling with speed and accuracy

Joffy122 — Mon, 08 Jun 2026 10:33:53 +0000