DEV Community: Joffy122

How to Use Search API Data for Lead Generation (And Stop Wasting Time on Manual Research)

Joffy122 — Mon, 29 Jun 2026 14:12:08 +0000

Disclosure: This article promotes products from Rook. Links may point to paid products.

If you're still manually digging through search results to find leads, you're leaving money on the table. Every minute spent copying URLs, scraping data, or cross-referencing spreadsheets is time you could spend closing deals or refining your strategy. The good news? You don’t need a fancy tool or a big budget to automate this process. With the right API, you can pull real-time search data, filter for high-intent leads, and feed them directly into your CRM—without writing a single line of code.

That’s where Rook’s Search API comes in. It’s a simple, pay-as-you-go way to access Google search results programmatically, with three plans to fit different needs:

Starter (£4.99 one-time) for 7-day access
Monthly (£9.99/month) for 1,000 searches
Annual (£89.99/year) for 1,000 searches/month, saving £29.89 versus paying monthly

You can try it for free first at demo.joffstrends.co.uk to see how it works before committing. No keys, no credit card, just a quick demo to test the waters.

Why Manual Lead Research is a Trap

Most small businesses and solopreneurs start with manual research because it feels "free." You open Google, type in a few keywords, and jot down the results. But here’s the problem:

It’s slow. Even a simple task like finding local contractors or B2B services can take hours.
It’s inconsistent. One day you miss a key result; the next day the rankings shift, and your list is outdated.
It doesn’t scale. If you need 100 leads instead of 10, you’re stuck doing it all over again.

The worst part? You’re probably missing high-intent leads because you’re not checking search results frequently enough. For example:

A local plumber might only check rankings once a week, missing a surge in "emergency plumber near me" searches after a storm.
A SaaS founder might overlook niche forums or Reddit threads where their ideal customers are asking questions.

Search data doesn’t lie. If people are searching for your solution, they’re ready to buy—you just need a way to find them before your competitors do.

How to Automate Lead Generation with Search API

The key to automating lead generation is turning raw search data into actionable insights. Here’s a step-by-step approach using Rook’s Search API:

Step 1: Define Your Lead Criteria

Start with a list of keywords that signal buying intent. For example:

"Best [your service] in [your city]" (local leads)
"How to [solve problem your product addresses]" (educational leads)
"[Competitor name] alternatives" (comparison leads)

You can use free tools like Google Keyword Planner or AnswerThePublic to brainstorm these, but the real magic happens when you combine them with search results.

Step 2: Pull Search Results Programmatically

With Rook’s Search API, you can fetch the top 10–100 results for any keyword in seconds. Here’s a simple Python example using the API:

import requests

api_key = "YOUR_API_KEY"  # Get this from your Gumroad purchase
keyword = "best CRM for small business"

url = f"https://api.joffstrends.co.uk/search?q={keyword}&key={api_key}"
response = requests.get(url)
results = response.json()

for result in results[:10]:  # Top 10 results
    print(f"Title: {result['title']}")
    print(f"URL: {result['url']}")
    print(f"Rank: {result['position']}")
    print("---")

This gives you structured data you can filter, sort, and export. No scraping, no rate limits, and no guesswork.

Step 3: Filter for High-Intent Leads

Not all search results are leads, but you can narrow them down using these filters:

Domain authority: Prioritize results from .gov, .edu, or well-known industry sites (these often indicate "best of" lists or directories).
Content type: Look for blog posts, forums, or "vs." comparison pages where people are researching solutions.
Recency: Check the publish date of the result. If it’s from the last 6 months, it’s more likely to be relevant

How to Use Search API Data for Rank Tracking (And Stop Guessing Your Rankings)

Joffy122 — Mon, 29 Jun 2026 04:35:38 +0000

Rank tracking doesn’t have to be a guessing game. If you’re manually checking positions in Google or relying on outdated tools, you’re likely missing critical insights that could improve your SEO strategy. The Search API from Rook (demo.joffstrends.co.uk) gives you real-time rank data for any keyword—without the bloated pricing of enterprise SERP APIs.

Why Most Rank Tracking Tools Are Overkill (or Overpriced)

Many developers and small businesses avoid dedicated rank tracking because:

Enterprise tools like SerpAPI or DataForSEO charge premium prices for features you don’t need.
Free tools either limit queries or lack accuracy.
Manual checks are time-consuming and inconsistent.

The Search API changes this. For just £9.99/month (or £89.99/year, saving £29.89), you get 1,000 searches monthly—enough to track hundreds of keywords without breaking the bank. No subscriptions, no hidden fees, just clean, actionable data.

How to Set Up Rank Tracking in 5 Minutes

1. Get Your API Key Instantly

Visit the free demo at demo.joffstrends.co.uk to test the API without commitment. When you’re ready, choose a plan:

Starter (£4.99 one-time, 7-day access)
Monthly (£9.99/month, 1,000 searches)
Annual (£89.99/year, 1,000 searches)

Your key arrives in your inbox within a minute. No waiting, no approvals.

2. Pull Rank Data Programmatically

The API returns JSON with position, URL, and snippet for any keyword. Here’s a Python example:

import requests

API_KEY = "your_key_here"
KEYWORD = "best running shoes"
URL = "https://api.joffstrends.co.uk/search"

params = {
    "q": KEYWORD,
    "key": API_KEY
}

response = requests.get(URL, params=params)
data = response.json()

print(f"Keyword: {KEYWORD}")
print(f"Rank: {data['position']}")
print(f"URL: {data['url']}")

Run this daily to log rankings in a spreadsheet or database. No complex dashboards—just raw data you control.

3. Automate Alerts for Ranking Changes

Combine the API with a simple script to email yourself when a keyword drops out of the top 10:

if data['position'] > 10:
    print(f"ALERT: {KEYWORD} dropped to position {data['position']}")

Set this up in cron or GitHub Actions for hands-off monitoring.

Real-World Use Cases

For Developers

Build custom dashboards without vendor lock-in.
Integrate rank data into existing SEO tools (e.g., Ahrefs/SEMrush alternatives).
A/B test title tags by comparing rankings before/after changes.

For Small Businesses

Track local rankings for "plumber near me" without paying for enterprise tools.
Monitor competitors by checking their top keywords.
Prioritize content updates based on actual performance.

For Content Creators

Find keyword gaps by comparing your rankings to competitors.
Validate new topics before writing (e.g., "Does ‘best vegan protein powder’ rank?").
Track seasonal trends (e.g., "When do ‘Christmas gift ideas’ rankings spike?").

Why This Beats "Free" Tools

Free rank trackers often:

Limit queries (e.g., 10/day).
Lack accuracy (cached data, no real-time updates).
Sell your data to third parties.

The Search API gives you:
✅ Real-time data (no delays).
✅ No rate limits (within your plan).
✅ Privacy-focused (your queries stay yours).

Save Money Without Sacrificing Quality

Here’s the math:

Monthly plan: £9.99 × 12 = £119.88/year.
Annual plan: £89.99/year (saves £29.89).

The annual plan is the best value if you’re tracking keywords long-term. No surprises—just a flat fee.

Next Steps

Test the free demo at [demo.joffstrends.co.uk

How to Choose the Right Search API Plan (And Save Money Without Sacrificing Quality)

Joffy122 — Mon, 29 Jun 2026 03:04:38 +0000

If you're evaluating search APIs, you've likely noticed that pricing structures vary wildly between providers. Some charge per request, others bundle requests into monthly tiers, and a few even offer pay-as-you-go models that can spiral out of control when usage spikes. At Rook, we've designed our Search API plans to balance affordability with flexibility, ensuring you get exactly what you need without hidden costs or unnecessary complexity.

The Search API offers three straightforward plans, each tailored to different use cases and budgets. Whether you're running a one-off analysis, need consistent monthly access, or want to lock in long-term savings, there's a plan designed for you. Let’s break down each option so you can make an informed decision—without the guesswork.

The Starter Plan: Perfect for One-Time Projects

Sometimes you just need a quick answer. Maybe you're testing a new tool, running a small experiment, or validating an idea before committing to a larger project. The Starter plan is built for these scenarios.

For a one-time payment of £4.99, you get 7 days of access to the Search API. That’s it. No subscriptions, no long-term commitments—just a straightforward way to dip your toes in without financial risk.

This plan is ideal if:

You're evaluating the API for a specific use case (e.g., checking a single keyword’s ranking).
You're a developer testing integration before scaling up.
You need a short-term solution for a client project or research task.

The key is delivered automatically via email within one minute of purchase, so you can start making requests immediately. No waiting, no friction—just instant access.

Where to buy: jonaoost.gumroad.com/l/mvqofn

The Monthly Plan: Flexibility for Ongoing Needs

If your work involves regular search API usage—whether for rank tracking, market research, or content auditing—the Monthly plan is likely the best fit. For £9.99 per month, you get 1,000 searches, which is enough for most small-scale projects or early-stage businesses.

This plan is designed for:

Freelancers or small agencies running periodic SEO audits.
Content creators tracking keyword performance over time.
Researchers collecting data for reports or studies.

The beauty of the Monthly plan is its simplicity. You pay as you go, with no surprises, and you can cancel anytime. It’s the perfect middle ground between the Starter plan’s short-term access and the Annual plan’s long-term savings.

Where to buy: jonaoost.gumroad.com/l/qtrhlc

The Annual Plan: Maximum Savings for Consistent Users

For those who know they’ll use the Search API regularly, the Annual plan is the most cost-effective option. At £89.99 per year, you get 1,000 searches per month—the same as the Monthly plan—but with a £29.89 savings compared to paying month-to-month.

Here’s the math:

Monthly plan: 12 × £9.99 = £119.88 per year.
Annual plan: £89.99 per year.
Savings: £29.89 (~25% cheaper).

This plan is ideal for:

Businesses or agencies with consistent search API needs.
Developers integrating the API into long-term projects.
Anyone who wants to budget predictably without worrying about monthly fluctuations.

The Annual plan locks in your costs upfront, so you’re not subject to price changes or unexpected fees. It’s the smart choice if you’re committed to using the Search API for the long haul.

Where to buy: jonaoost.gumroad.com/l/yadprx

How to Decide Which Plan Is Right for You

Choosing the right plan depends entirely on your needs, budget, and usage patterns. Here’s a quick decision guide:

Need it for a short-term project? → Starter plan (£4.99, 7 days).
Using it occasionally but regularly? → Monthly plan (£9.99/month, 1,000 searches).
Using it consistently for a year or more? → Annual plan (£89.99/year, 1,000 searches/month, saves £29.89).

If you're unsure, start with the Starter plan

How to Use Search API Data for Lead Generation (And Stop Wasting Time on Manual Prospecting)

Joffy122 — Sat, 27 Jun 2026 21:20:56 +0000

Disclosure: This article promotes products from Rook. Links may point to paid products.

If you're running a small business or a solo sales operation, you know the pain of manual lead generation. You spend hours scraping websites, checking directories, or relying on outdated contact lists—only to end up with a handful of low-quality leads. Meanwhile, your competitors are using data-driven tools to automate the process, leaving you behind.

The good news? You don’t need a big budget or complex software to level the playing field. With the right search API, you can extract high-intent leads in minutes, not hours. And you can try it for free before committing to a paid plan.

Why Manual Lead Generation Fails

Most small businesses start with manual methods because they’re "free." But here’s the catch:

Time sink: Hours spent copying emails from LinkedIn or Google Maps.
Low accuracy: Outdated contact info means wasted outreach.
No scalability: You can’t process hundreds of leads at once.

A search API changes this by automating the heavy lifting. Instead of guessing where to find leads, you pull real-time data—like business names, emails, or phone numbers—based on your ideal customer profile.

How Search API Data Powers Lead Generation

Let’s break down a simple workflow using Rook’s Search API:

Define your target: Say you’re selling CRM software to UK-based accountants.
Pull relevant data: Use the API to fetch businesses in the "accounting" industry.
Extract contact details: The API can return emails or phone numbers (where available).
Automate outreach: Plug the leads into your CRM or email tool.

This isn’t theoretical—it’s exactly how Rook’s API works. For example, the Starter plan (£4.99 one-time) gives you 7 days of access to test the workflow. If it works for you, you can scale up to the Monthly plan (£9.99/month for 1,000 searches) or the Annual plan (£89.99/year for 1,000 searches/month).

Pro tip: The Annual plan saves you £29.89 compared to paying monthly all year (12 × £9.99 = £119.88).

Real-World Use Cases

Here’s how different teams use search API data for lead generation:

Freelancers: Find local clients by industry (e.g., "web designers in Manchester").
Agencies: Build targeted lists for cold email campaigns.
SaaS startups: Validate demand by checking how many businesses search for your product.

No more spreadsheets filled with dead ends. Just clean, actionable data.

Try It Before You Buy

Before committing to a plan, test the waters with Rook’s free demo at demo.joffstrends.co.uk. No key or purchase needed—just plug in a search query and see the results in real time.

If the demo works for you, grab a key instantly from:

Final Thoughts

Manual lead generation is a relic of the past. With a search API, you can automate the grunt work, focus on high-value tasks, and close more deals. The best part? You can start for less than the cost of a coffee.

Give the free demo a try today—your future leads (and your sanity) will thank you.

How to Use Search API Data for Content Gap Analysis (And Stop Guessing What Your Audience Wants)

Joffy122 — Sat, 27 Jun 2026 20:50:32 +0000

Disclosure: This article promotes products from Rook. Links may point to paid products.

Every piece of content you publish is a bet. You’re betting that your audience will care about the topics you’ve chosen, that your keywords will rank, and that your insights will resonate. But what if you’re betting on the wrong things? What if your competitors are answering questions your audience is asking—and you’re not?

Content gap analysis is the process of identifying those missing pieces in your content strategy. It’s how you find the topics your audience is searching for that you haven’t covered yet. And the fastest way to do it? Search API data.

In this guide, I’ll show you how to use the Search API (a self-hosted, pay-once alternative to expensive SERP APIs) to uncover content gaps in minutes—not hours. No subscriptions, no per-request fees, and no guessing. Just real search data that tells you exactly what your audience wants.

Why Content Gap Analysis Matters (And Why Most People Skip It)

Most content strategies are built on assumptions. You think you know what your audience wants because you’ve been in the industry for years, or because you’ve read a few competitor blogs. But assumptions are dangerous. They lead to:

Wasted effort: You write about topics that get little traffic.
Missed opportunities: Competitors rank for keywords you ignored.
Stale content: Your old posts become irrelevant because search trends shift.

Content gap analysis flips the script. Instead of guessing, you let search data guide your decisions. The result? Higher rankings, more traffic, and content that actually moves the needle.

The Problem with Traditional Gap Analysis Tools

Most gap analysis tools fall into two camps:

Free tools (Google Search Console, AnswerThePublic): Limited data, slow, and often incomplete.
Paid tools (Ahrefs, SEMrush, Moz): Expensive, subscription-based, and overkill for small teams.

Both approaches have a critical flaw: they don’t give you raw search data. They show you what people are searching for, but not how they’re searching. That’s where a Search API comes in.

How the Search API Solves the Problem

The Search API is a simple but powerful tool that lets you query search engines programmatically. Here’s how it works:

You send a search query (e.g., "best running shoes for flat feet").
The API returns structured data (search volume, top results, featured snippets, etc.).
You analyze the gaps between what’s ranking and what you’ve covered.

Unlike traditional tools, the Search API gives you:

Raw search data (no aggregations or estimates).
No rate limits (unlike free tools).
One-time payment (no subscriptions).

Step-by-Step: Finding Content Gaps with Search API Data

Let’s walk through a real example. Suppose you run a fitness blog, and you want to find gaps in your content around "running shoes." Here’s how you’d use the Search API to uncover opportunities.

Step 1: Identify Your Topics

Start with broad topics related to your niche. For a fitness blog, these might include:

Running shoes
Yoga mats
Protein powders
Home workouts

Step 2: Query the Search API

Use the free demo to test queries. For "running shoes," you might search:

"best running shoes for flat feet"

The API returns:

Top 10 results (URLs, titles, descriptions).
Featured snippets (if any).
Search volume (if available).

Step 3: Compare with Your Content

Now, check your blog for coverage of these topics. For example:

Do you have a post on "best running shoes for flat feet"?
If not, is there a related post (e.g., "best running shoes for beginners") that could be expanded?
Are competitors ranking for these queries with content you don’t have?

Step 4: Prioritize Gaps

Not all gaps are equal. Use these criteria to prioritize:

Search volume: High-volume queries are worth targeting.
Relevance: Does the topic align with your audience’s needs?
Competition: Can you realistically rank for this query?

For example, if "best running shoes for flat feet" has high volume but no competitor has a comprehensive guide, that’s a prime opportunity.

How to Use Search API Data for Content Gap Analysis (And Stop Guessing What Your Audience Wants)

Joffy122 — Sat, 27 Jun 2026 20:20:22 +0000

Disclosure: This article promotes products from Rook. Links may point to paid products.

Every time you publish a blog post, you’re making a bet: that your content will resonate with your audience. But what if you’re betting on the wrong keywords? What if your competitors are already ranking for terms your audience is searching for, while you’re left wondering why your traffic isn’t growing?

This isn’t just a hypothetical—it’s a daily reality for content creators, marketers, and SEO professionals. The problem isn’t a lack of ideas; it’s the inability to systematically identify the gaps in your content strategy. Manual research is time-consuming, expensive SERP APIs drain your budget, and spreadsheets can’t tell you what’s missing until it’s too late.

Enter the Search API from Rook. It’s a self-hosted alternative to expensive SERP tools that gives you direct access to search data—without the monthly fees or rate limits. In this guide, I’ll show you how to use it to perform a content gap analysis that actually works, so you can stop guessing and start ranking.

What Is a Content Gap Analysis?

A content gap analysis is the process of identifying topics your audience is searching for that you aren’t covering. It’s not about duplicating your competitors’ content—it’s about finding the unmet needs in your niche and filling them before someone else does.

Here’s how it typically works:

Identify high-intent keywords your audience is searching for.
Compare your current content against those keywords.
Prioritize gaps based on search volume, competition, and business relevance.
Create or optimize content to fill those gaps.

The challenge? Doing this at scale without spending a fortune on tools like Ahrefs, SEMrush, or SerpAPI. Most free tools either limit you to a handful of searches or require you to manually scrape data—neither of which is practical for ongoing analysis.

Why Most Content Gap Analyses Fail

Before we dive into the how, let’s talk about the why. Most content gap analyses fail for three reasons:

They rely on incomplete data. Free tools like Google Search Console or Google Trends give you some insights, but they’re not granular enough to spot real gaps. You end up with vague recommendations like “write more about X” without knowing how much demand there is for X.
They’re too manual. Copying competitor URLs into a spreadsheet and cross-referencing with your own content is tedious. It’s easy to miss gaps or overlook high-value opportunities because the process is error-prone.
They don’t account for search intent. Not all keywords are created equal. A keyword like “best running shoes for flat feet” has a very different intent than “running shoes reviews.” If you’re not analyzing intent, you’re optimizing for the wrong queries.

The Search API solves all three of these problems. It gives you real-time search data (no rate limits), automated gap detection, and intent-based filtering—all for a fraction of the cost of traditional tools.

How to Perform a Content Gap Analysis with the Search API

Here’s a step-by-step process to identify and fill content gaps using the Search API. I’ll use a real example: a hypothetical blog about home workouts.

Step 1: Define Your Seed Keywords

Start with a list of broad terms your audience might search for. For home workouts, these could be:

“home workouts for beginners”
“best home workout equipment”
“10-minute home workouts”
“home workout routines for weight loss”

You can pull these from your existing content, competitor analysis, or tools like AnswerThePublic. The goal is to have a starting point—not a perfect list.

Step 2: Fetch Search Volume and Competition Data

This is where the Search API shines. Instead of manually checking each keyword in Google or a paid tool, you can automate the process with a simple API call. Here’s how:

Get your API key. Sign up for the Search API Starter plan (£4.99 one-time for 7-day access) or the Monthly plan (£9.99/month for 1,000 searches). The key is emailed to you within 1 minute.
Make an API request. The Search API returns search volume, competition score, and top-ranking pages for any keyword. Here’s a sample request (using Python):

How to Use Search API Data for Academic Research (And Stop Wasting Time on Manual Data Collection)

Joffy122 — Sat, 27 Jun 2026 20:20:21 +0000

Academic research often requires collecting large volumes of search engine results to analyze trends, validate hypotheses, or track keyword performance. Whether you're studying consumer behavior, monitoring public sentiment, or conducting SEO research, manually gathering this data is time-consuming, error-prone, and often incomplete. The free demo at demo.joffstrends.co.uk lets you test the Search API without any commitment, but when you're ready to scale your research, the paid plans provide the reliability and volume you need.

Disclosure: This article promotes products from Rook. Links may point to paid products.

Why Academics Need a Reliable Search API

Many researchers rely on manual methods—copying search results into spreadsheets, scraping pages, or using limited free tools that throttle requests. These approaches have critical flaws:

Inconsistent data: Search results vary by location, device, and personalization, making manual collection unreliable for longitudinal studies.
Time wasted: Hours spent copying and formatting data could be spent analyzing results.
Limited scope: Free tools often cap requests or return incomplete datasets, forcing researchers to work with smaller sample sizes than needed.

A dedicated search API solves these problems by delivering structured, consistent, and scalable data. The Rook Search API provides real-time search results via a simple REST endpoint, with no rate limits or hidden throttling. For academic work, this means:

Reproducible results: API calls return the same data regardless of user location or session history.
Automated workflows: Integrate the API into Python scripts, R programs, or even Google Sheets to pull data on demand.
Higher data volume: The Monthly plan (£9.99/month) includes 1,000 searches, while the Annual plan (£89.99/year) offers the same usage for £29.89 less than paying monthly.

Real-World Use Cases for Academic Research

Here’s how researchers are already using the Search API to improve their work:

1. Tracking Keyword Trends Over Time

A PhD student studying climate change communication needed to track how media coverage of "carbon neutrality" evolved from 2020 to 2024. Manually collecting monthly search results would have taken days per month. Instead, they automated the process using the API, pulling weekly snapshots and analyzing shifts in terminology and sentiment. The Annual plan’s cost savings made this feasible on a tight budget.

2. Analyzing Public Sentiment by Region

A sociology team researching regional differences in vaccine hesitancy required localized search data. The API’s ability to return results filtered by country or city (where supported) let them compare query volumes for terms like "vaccine side effects" across different regions. The Starter plan’s one-time £4.99 fee was perfect for a small pilot study before committing to a larger plan.

3. Validating Research Hypotheses with SERP Data

A marketing professor testing whether "AI tools" searches correlate with SaaS adoption rates used the API to pull monthly search volumes for related keywords. By cross-referencing this data with software adoption statistics, they identified a strong correlation—something impossible to detect with manual methods.

4. Competitive Analysis in Niche Fields

A biotech researcher studying CRISPR patent filings needed to track how often competitors’ names appeared in patent-related searches. The API’s ability to return search volumes for specific queries helped them identify rising players in the space before they hit mainstream news.

How to Get Started with the Search API

The fastest way to test the API is with the free demo at demo.joffstrends.co.uk. No key is required—just enter a search term and see the JSON response instantly. If you like what you see, you can upgrade to a paid plan in seconds:

Starter plan (£4.99 one-time): 7-day access for quick projects or testing. Get it here.
Monthly plan (£9.99/month): 1,000 searches/month for ongoing research. Get it here.
Annual plan (£89.99/year): 1,000 searches/month with a 25% discount. The Annual plan (£89.99/year) saves £29.89 compared with paying month-to-month (12 × £9.99 = £119.88). Get it here.

AgentJobs: Non-Custodial Agent-to-Agent Escrow, Live on Monad

Joffy122 — Wed, 24 Jun 2026 20:21:02 +0000

The problem

AI agents are starting to hire each other — one agent delegates a sub-task to another, pays for the output, moves on. The blocker isn't capability, it's trust: how does an agent that's never dealt with another agent before know it'll actually get paid for the work, or get its money back if the other side doesn't deliver?

What AgentJobs does

AgentJobs is a small, non-custodial escrow contract built for exactly that. A client posts a job and funds it in USDC. A provider does the work. An evaluator — who can be the client itself, or an independent third agent — confirms it's done. The contract releases the funds. If nothing happens before the deadline, the client claims a refund.

It's loosely inspired by the ERC-8183 agent-hiring pattern that's been gaining traction this year.

The lifecycle

createJob(provider, evaluator, expiredAt, description) — client opens the job
setBudget(jobId, amount) + fund(jobId, expectedBudget) — client deposits USDC into escrow
submit(jobId, deliverable) — provider delivers
complete(jobId) — evaluator approves, funds release minus a 10% platform fee
claimRefund(jobId) — if the deadline passes with no resolution, the client gets their money back

No step requires trusting anyone outside the job itself.

Why non-custodial, specifically

There's no Ownable, no AccessControl, no admin role of any kind in this contract. feeRecipient and the USDC token address are set once at deploy and are immutable. There's no pause function, no withdraw function, no sweep function. Whoever deploys this contract gets zero ongoing control over it — by design.

That felt worth writing down explicitly, because it's the opposite of how a lot of "trust us" marketplace contracts get built.

Live on Monad

Contract: 0x55f4E4fA515986e4C58Dda008f34600d20665143 — verified source
Chain: Monad mainnet (chainId 143)
Settlement: native USDC
Fee: 10%, only on successful completion, never on refund

A real job has already run through the full lifecycle end-to-end — created, funded, submitted, completed — all on-chain.

Why Monad

Near-zero gas and fast finality matter a lot here — agent-to-agent transactions are meant to happen constantly, not occasionally. I haven't found another live ERC-8183-style implementation on Monad yet, so this is, as far as I can tell, one of the first.

Try it

Code: https://github.com/Joffy122/agent-jobs
Live dashboard: https://agentjobs.joffstrends.co.uk
Contract: https://monadscan.com/address/0x55f4E4fA515986e4C58Dda008f34600d20665143

12/12 tests passing, source verified, MIT licensed. Feedback and PRs welcome.

How to Build a Real-Time Search Engine Interface in Vue.js 3 with Joffstrends Search API

Joffy122 — Thu, 18 Jun 2026 14:26:47 +0000

How to Build a Real-Time Search Engine Interface in Vue.js 3 with Joffstrends Search API

In modern web development, providing users with a fast, responsive, and accurate search interface is a crucial feature. Whether you are building a news aggregator, a content discovery platform, or a custom dashboard, integrating a reliable search API can elevate your application's user experience.

In this tutorial, we will walk through how to build a real-time search interface using Vue.js 3 (with the Composition API and Vite) and the Joffstrends Search API.

The Joffstrends Search API is an incredibly affordable, high-performance search API designed for developers. With plans starting as low as £4.99 for a starter pack or £9.99/month for 1,000 searches, it is an excellent alternative to more expensive search APIs on the market. You can grab your API key from Gumroad and get started in minutes.

Prerequisites

Before we begin, make sure you have the following:

Node.js (version 16 or higher) installed on your machine.
Basic familiarity with Vue.js 3 and the Composition API.
A Joffstrends Search API Key (which you can obtain from the Gumroad Monthly Plan or the Starter Plan).

Step 1: Setting Up Your Vue.js 3 Project

We will use Vite to scaffold a new Vue 3 project quickly. Open your terminal and run:

npm create vue@latest vue-joffstrends-search

Follow the prompts to configure your project. For this tutorial, we can keep it simple:

Add TypeScript? No
Add JSX Support? No
Add Vue Router? No
Add Pinia? No
Add Vitest? No
Add ESLint? Yes

Once the scaffolding is complete, navigate into your project directory and install the dependencies:

cd vue-joffstrends-search
npm install

Now, let's start the development server to make sure everything is working:

npm run dev

Step 2: Configuring Environment Variables

To keep our API key secure, we should store it in an environment variable. Create a .env file in the root of your project:

VITE_JOFFSTRENDS_API_KEY=your_actual_api_key_here

Vite automatically loads environment variables prefixed with VITE_, making them accessible in our Vue components via import.meta.env.VITE_JOFFSTRENDS_API_KEY.

Step 3: Creating the Search Service

Let's create a clean, reusable service to handle our API requests. Create a new file named src/services/searchService.js:

const API_URL = 'https://api.joffstrends.co.uk/search';
const API_KEY = import.meta.env.VITE_JOFFSTRENDS_API_KEY;

export async function fetchSearchResults(query) {
  if (!query || query.trim() === '') {
    return [];
  }

  try {
    const response = await fetch(`${API_URL}?q=${encodeURIComponent(query)}`, {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
      }
    });

    if (!response.ok) {
      throw new Error(`API Error: ${response.status} ${response.statusText}`);
    }

    const data = await response.json();
    return data.results || data || [];
  } catch (error) {
    console.error('Failed to fetch search results:', error);
    throw error;
  }
}

Step 4: Building the Search Component

Now, let's build a highly reactive search component. We will implement debouncing to prevent making API calls on every single keystroke, which helps save API quota and improves performance.

Create a new component at src/components/SearchInterface.vue:

<template>
  <div class="search-container">
    <h1>Joffstrends Search Explorer</h1>
    <p class="subtitle">Powering real-time search with Vue 3 and Joffstrends API</p>

    <div class="search-box">
      <input
        v-model="searchQuery"
        type="text"
        placeholder="Search for news, trends, or topics..."
        @input="handleInput"
        class="search-input"
      />
      <button @click="triggerSearch" class="search-button" :disabled="loading">
        Search
      </button>
    </div>

    <!-- Loading State -->
    <div v-if="loading" class="status-message loading">
      <div class="spinner"></div> Searching...
    </div>

    <!-- Error State -->
    <div v-if="error" class="status-message error">
      {{ error }}
    </div>

    <!-- Results List -->
    <div v-if="results.length > 0" class="results-list">
      <div v-for="(result, index) in results" :key="index" class="result-card">
        <h3>
          <a :href="result.url" target="_blank" rel="noopener noreferrer">
            {{ result.title || 'Untitled Result' }}
          </a>
        </h3>
        <p class="snippet">{{ result.snippet || 'No description available.' }}</p>
        <span class="source" v-if="result.source">{{ result.source }}</span>
      </div>
    </div>

    <!-- Empty State -->
    <div v-else-if="searchQuery && !loading && !error" class="status-message empty">
      No results found for "{{ searchQuery }}". Try another query!
    </div>
  </div>
</template>

<script setup>
import { ref } from 'vue';
import { fetchSearchResults } from '../services/searchService';

const searchQuery = ref('');
const results = ref([]);
const loading = ref(false);
const error = ref(null);
let debounceTimeout = null;

const triggerSearch = async () => {
  if (!searchQuery.value.trim()) {
    results.value = [];
    return;
  }

  loading.value = true;
  error.value = null;

  try {
    results.value = await fetchSearchResults(searchQuery.value);
  } catch (err) {
    error.value = 'An error occurred while fetching search results. Please try again.';
    results.value = [];
  } finally {
    loading.value = false;
  }
};

const handleInput = () => {
  if (debounceTimeout) {
    clearTimeout(debounceTimeout);
  }

  debounceTimeout = setTimeout(() => {
    triggerSearch();
  }, 500);
};
</script>

<style scoped>
.search-container {
  max-width: 800px;
  margin: 0 auto;
  padding: 2rem;
  font-family: 'Inter', sans-serif;
}

h1 {
  color: #2c3e50;
  margin-bottom: 0.5rem;
  text-align: center;
}

.subtitle {
  color: #7f8c8d;
  text-align: center;
  margin-bottom: 2rem;
}

.search-box {
  display: flex;
  gap: 10px;
  margin-bottom: 2rem;
}

.search-input {
  flex: 1;
  padding: 12px 20px;
  font-size: 16px;
  border: 2px solid #ddd;
  border-radius: 8px;
  outline: none;
  transition: border-color 0.3s;
}

.search-input:focus {
  border-color: #3498db;
}

.search-button {
  padding: 12px 24px;
  font-size: 16px;
  background-color: #3498db;
  color: white;
  border: none;
  border-radius: 8px;
  cursor: pointer;
  transition: background-color 0.3s;
}

.search-button:hover {
  background-color: #2980b9;
}

.search-button:disabled {
  background-color: #bdc3c7;
  cursor: not-allowed;
}

.status-message {
  text-align: center;
  font-size: 16px;
  margin: 2rem 0;
}

.error {
  color: #e74c3c;
}

.results-list {
  display: flex;
  flex-direction: column;
  gap: 1.5rem;
}

.result-card {
  padding: 1.5rem;
  border: 1px solid #e2e8f0;
  border-radius: 8px;
  background-color: #fff;
  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.02);
  transition: transform 0.2s, box-shadow 0.2s;
}

.result-card:hover {
  transform: translateY(-2px);
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
}

.result-card h3 {
  margin: 0 0 0.5rem 0;
}

.result-card a {
  color: #2b6cb0;
  text-decoration: none;
}

.result-card a:hover {
  text-decoration: underline;
}

.snippet {
  color: #4a5568;
  font-size: 14px;
  line-height: 1.6;
  margin: 0 0 0.75rem 0;
}

.source {
  font-size: 12px;
  color: #718096;
  background-color: #edf2f7;
  padding: 4px 8px;
  border-radius: 4px;
}
</style>

Step 5: Integrating the Component in App.vue

Now, let's clean up src/App.vue and render our new SearchInterface component. Replace the contents of src/App.vue with:

<template>
  <main>
    <SearchInterface />
  </main>
</template>

<script setup>
import SearchInterface from './components/SearchInterface.vue';
</script>

<style>
body {
  background-color: #f7fafc;
  margin: 0;
  padding: 0;
}
</style>

Why Choose Joffstrends Search API?

When building search-driven applications, developers are often faced with complex setups or expensive monthly fees. The Joffstrends Search API simplifies this by offering:

Simplicity: A single, clean endpoint (https://api.joffstrends.co.uk/search?q=query) that returns structured JSON results.
Affordability: Perfect for indie hackers, side projects, and startups. You don't need to commit to hundreds of dollars a month just to get reliable search results.
Speed: Fast response times ensure your Vue.js reactive interfaces feel snappy and instant.

To get your API key, check out the options on Gumroad:

Starter Plan (£4.99 one-time) - Perfect for testing and prototyping.
Monthly Subscription (£9.99/month) - Ideal for live applications requiring regular search access.

Conclusion

With Vue 3's Composition API and the Joffstrends Search API, building a real-time, debounced search interface is incredibly straightforward. You can easily extend this project by adding pagination, search filters, or saving search history in localStorage.

Happy coding! Let us know in the comments what you plan to build with Vue and Joffstrends.

How to Build a Real-Time Search and News Feed Component in React with Joffstrends Search API

Joffy122 — Thu, 18 Jun 2026 07:53:18 +0000

How to Build a Real-Time Search and News Feed Component in React with Joffstrends Search API

In today's fast-paced digital landscape, users expect instant access to information. Whether you are building a personal dashboard, a curated news aggregator, or a market intelligence tool, integrating real-time web search capabilities directly into your frontend can significantly elevate the user experience.

However, many established search APIs are either prohibitively expensive or overly complex to set up. Enter the Joffstrends Search API—a lightweight, fast, and highly cost-effective search API designed specifically for developers who need reliable search results without the enterprise price tag.

In this comprehensive tutorial, we will walk through how to build a fully functional, responsive real-time search and news feed component in React using the Joffstrends Search API. We will cover everything from project setup and API authentication to state management, error handling, and modern UI styling.

Prerequisites

To follow along with this tutorial, you will need:

Node.js (v16 or higher) and npm/yarn installed on your machine.
A basic understanding of React (specifically functional components and hooks like useState and useEffect).
A Joffstrends Search API Key.

Getting Your API Key

If you don't have an API key yet, you can obtain one instantly via Gumroad. Joffstrends offers three flexible tiers depending on your project needs:

Starter Plan: £4.99 one-time payment for 7 days of full access (perfect for testing and hackathons). Get Starter Plan
Monthly Subscription: £9.99/month for 1,000 searches/month (ideal for hobbyists and small apps). Get Monthly Plan
Annual Subscription: £89.99/year for 1,000 searches/month, saving you about 3 months of subscription costs. Get Annual Plan

Once purchased, your unique API key will be emailed to you within approximately one minute.

Step 1: Setting Up Your React Project

We will use Vite to scaffold a modern, ultra-fast React application. Open your terminal and run the following commands:

# Create a new Vite project with React and TypeScript/JavaScript
npm create vite@latest joffstrends-search-app -- --template react

# Navigate into the project directory
cd joffstrends-search-app

# Install dependencies
npm install

For styling, we will use standard CSS in this guide to keep it dependency-free, but you can easily adapt the classes to Tailwind CSS or styled-components.

Step 2: Securing Your API Key

To prevent hardcoding your API key directly into your source code, we will use environment variables. Create a file named .env in the root of your project:

VITE_JOFFSTRENDS_API_KEY=your_actual_api_key_here

Note: In a production environment, making direct API calls from the client-side exposes your API key to anyone inspecting network traffic. For production apps, we highly recommend routing these requests through a simple backend proxy or serverless function. For the purpose of this frontend integration tutorial, we will use the environment variable directly.

Step 3: Designing the Search Component

Let's create a dedicated component for our search feed. Create a new file at src/components/SearchFeed.jsx (or .tsx if using TypeScript).

We need to manage several states:

query: The current search term entered by the user.
results: An array of search results returned by the API.
loading: A boolean to track whether an API request is in progress.
error: A string to capture and display any API or network errors.

Here is the complete implementation of the SearchFeed component:

import React, { useState } from 'react';
import './SearchFeed.css';

const SearchFeed = () => {
  const [query, setQuery] = useState('');
  const [results, setResults] = useState([]);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState('');

  const handleSearch = async (e) => {
    e.preventDefault();
    if (!query.trim()) return;

    setLoading(true);
    setError('');
    setResults([]);

    const apiKey = import.meta.env.VITE_JOFFSTRENDS_API_KEY;
    const endpoint = `https://api.joffstrends.co.uk/search?q=${encodeURIComponent(query)}`;

    try {
      const response = await fetch(endpoint, {
        method: 'GET',
        headers: {
          'x-api-key': apiKey,
          'Content-Type': 'application/json',
        },
      });

      if (!response.ok) {
        if (response.status === 401 || response.status === 403) {
          throw new Error('Unauthorized: Please check your Joffstrends API key.');
        }
        throw new Error(`Error: ${response.status} ${response.statusText}`);
      }

      const data = await response.json();

      // Assuming the API returns an array of results directly or inside a results field
      // Adjust this based on the exact payload structure
      const searchResults = Array.isArray(data) ? data : data.results || [];
      setResults(searchResults);
    } catch (err) {
      console.error('Search API Error:', err);
      setError(err.message || 'Something went wrong. Please try again.');
    } finally {
      setLoading(false);
    }
  };

  return (
    <div className="search-container">
      <header className="search-header">
        <h1>Joffstrends Real-Time Feed</h1>
        <p>Search the web instantly using the Joffstrends Search API</p>
      </header>

      <form onSubmit={handleSearch} className="search-form">
        <input
          type="text"
          placeholder="Search for news, trends, or topics..."
          value={query}
          onChange={(e) => setQuery(e.target.value)}
          className="search-input"
        />
        <button type="submit" className="search-button" disabled={loading}>
          {loading ? 'Searching...' : 'Search'}
        </button>
      </form>

      {error && <div className="search-error">{error}</div>}

      {loading && (
        <div className="search-loader">
          <div className="spinner"></div>
          <p>Fetching latest results...</p>
        </div>
      )}

      {!loading && results.length === 0 && query && !error && (
        <div className="search-no-results">
          No results found for "{query}". Try another search term!
        </div>
      )}

      <div className="search-results-grid">
        {results.map((item, index) => (
          <article key={index} className="result-card">
            <h2 className="result-title">
              <a href={item.link || item.url} target="_blank" rel="noopener noreferrer">
                {item.title}
              </a>
            </h2>
            <p className="result-snippet">{item.snippet || item.description}</p>
            <div className="result-footer">
              <span className="result-source">{item.source || 'Web Result'}</span>
              <a href={item.link || item.url} target="_blank" rel="noopener noreferrer" className="result-link">
                Read More &rarr;
              </a>
            </div>
          </article>
        ))}
      </div>
    </div>
  );
};

export default SearchFeed;

Step 4: Styling the Component

To make our component look modern and clean, let's add some CSS. Create a file named src/components/SearchFeed.css and paste the following styles:

.search-container {
  max-width: 900px;
  margin: 0 auto;
  padding: 40px 20px;
  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
  color: #333;
}

.search-header {
  text-align: center;
  margin-bottom: 40px;
}

.search-header h1 {
  font-size: 2.5rem;
  color: #111;
  margin-bottom: 10px;
}

.search-header p {
  font-size: 1.1rem;
  color: #666;
}

.search-form {
  display: flex;
  gap: 12px;
  margin-bottom: 30px;
}

.search-input {
  flex: 1;
  padding: 14px 20px;
  font-size: 1rem;
  border: 2px solid #ddd;
  border-radius: 8px;
  outline: none;
  transition: border-color 0.2s ease;
}

.search-input:focus {
  border-color: #0070f3;
}

.search-button {
  padding: 14px 28px;
  font-size: 1rem;
  font-weight: 600;
  color: #fff;
  background-color: #0070f3;
  border: none;
  border-radius: 8px;
  cursor: pointer;
  transition: background-color 0.2s ease;
}

.search-button:hover {
  background-color: #0051a2;
}

.search-button:disabled {
  background-color: #999;
  cursor: not-allowed;
}

.search-error {
  padding: 15px;
  background-color: #fee2e2;
  color: #dc2626;
  border-radius: 8px;
  margin-bottom: 30px;
  font-weight: 500;
}

.search-loader {
  text-align: center;
  padding: 40px 0;
  color: #666;
}

.spinner {
  border: 4px solid rgba(0, 0, 0, 0.1);
  width: 36px;
  height: 36px;
  border-radius: 50%;
  border-left-color: #0070f3;
  animation: spin 1s linear infinite;
  margin: 0 auto 15px;
}

@keyframes spin {
  0% { transform: rotate(0deg); }
  100% { transform: rotate(360deg); }
}

.search-no-results {
  text-align: center;
  padding: 40px 0;
  color: #666;
  font-size: 1.1rem;
}

.search-results-grid {
  display: grid;
  grid-template-columns: 1fr;
  gap: 20px;
}

@media (min-width: 600px) {
  .search-results-grid {
    grid-template-columns: repeat(2, 1fr);
  }
}

.result-card {
  background: #fff;
  border: 1px solid #e5e7eb;
  border-radius: 12px;
  padding: 24px;
  display: flex;
  flex-direction: column;
  justify-content: space-between;
  transition: transform 0.2s ease, box-shadow 0.2s ease;
}

.result-card:hover {
  transform: translateY(-2px);
  box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1);
}

.result-title {
  font-size: 1.25rem;
  margin: 0 0 12px 0;
  line-height: 1.4;
}

.result-title a {
  color: #111;
  text-decoration: none;
  transition: color 0.2s ease;
}

.result-title a:hover {
  color: #0070f3;
}

.result-snippet { 
  font-size: 0.95rem;
  color: #4b5563;
  line-height: 1.6;
  margin: 0 0 20px 0;
  flex-grow: 1;
}

.result-footer {
  display: flex;
  justify-content: space-between;
  align-items: center;
  font-size: 0.85rem;
}

.result-source {
  background-color: #f3f4f6;
  color: #4b5563;
  padding: 4px 8px;
  border-radius: 4px;
  font-weight: 500;
}

.result-link {
  color: #0070f3;
  text-decoration: none;
  font-weight: 600;
}

.result-link:hover {
  text-decoration: underline;
}

Step 5: Integrating the Component

Now, let's render our new SearchFeed component in the main application file. Open src/App.jsx and replace its content with:

import React from 'react';
import SearchFeed from './components/SearchFeed';
import './App.css';

function App() {
  return (
    <div className="App">
      <SearchFeed />
    </div>
  );
}

export default App;

Run your development server to see it in action:

npm run dev

Open your browser to the local URL provided by Vite (usually http://localhost:5173), enter a search query, and watch your real-time news feed populate instantly!

Best Practices & Next Steps

Now that you have a working integration, here are a few ways to optimize and enhance your application:

Implement Debouncing: If you want to fetch results as the user types instead of requiring a form submission, use a debounce function (like Lodash's debounce) to delay the API call until the user has stopped typing for 300-500ms. This prevents hitting your API rate limits unnecessarily.
Build a Backend Proxy: As mentioned earlier, to secure your API key in production, create a simple Express.js or Next.js API route that acts as a middleman. Your React frontend calls your backend endpoint, and your backend appends the x-api-key header and forwards the request to api.joffstrends.co.uk.
Add Pagination: If your application requires browsing multiple pages of results, you can easily implement pagination by passing offset or page parameters to the Joffstrends Search API (refer to the official documentation for supported query parameters).

Conclusion

Integrating real-time web search into a React application doesn't have to be expensive or complicated. With the Joffstrends Search API and standard React hooks, you can build a responsive, beautiful search feed in under an hour.

Ready to build your own? Head over to Gumroad to grab your API key and start building today:

Happy coding!

Building a Real-Time News Aggregator and Trend Tracker with Python and Joffstrends Search API

Joffy122 — Wed, 17 Jun 2026 19:43:12 +0000

Building a Real-Time News Aggregator and Trend Tracker with Python and Joffstrends Search API

In the modern era of artificial intelligence and large language models (LLMs), access to clean, structured, and real-time web search data is more critical than ever. Whether you are building an AI agent, a market intelligence dashboard, or a simple automated news aggregator, you need a search API that is fast, reliable, and cost-effective.

While major search engines offer APIs, they are often notoriously expensive, complex to set up, and gated behind heavy enterprise contracts. This is where the Joffstrends Search API shines. It provides a streamlined, developer-first interface to query the web and retrieve structured search results instantly.

In this comprehensive tutorial, we will walk through how to integrate the Joffstrends Search API with Python. We will build a practical, production-ready command-line News Aggregator and Trend Tracker script that fetches real-time search results, filters them, and exports them to a structured format (JSON) ready for analysis or LLM ingestion.

Why Joffstrends Search API?

Before we dive into the code, let’s look at why the Joffstrends Search API is an excellent choice for developers:

Simplicity: No complex OAuth flows or multi-layered configurations. You pass a query and your API key, and you get clean JSON back.
Affordability: With plans starting at just £4.99, it is highly accessible for indie hackers, students, and startups.
Speed: Optimized for rapid response times, making it ideal for real-time applications.
Structured Output: Returns clean, parsed search results (titles, links, snippets) that are easy to manipulate programmatically.

Prerequisites

To follow along with this tutorial, you will need:

Python 3.7 or higher installed on your machine.
A Joffstrends Search API Key. If you don't have one yet, you can obtain it instantly via Gumroad:
- Starter Plan (£4.99 one-time, 7 days access): Get Starter Plan
- Monthly Plan (£9.99/month, 1,000 searches/month): Get Monthly Plan
- Annual Plan (£89.99/year, 1,000 searches/month): Get Annual Plan (Note: Your unique API key is emailed to you within approximately 1 minute of purchase.)

Setting Up Your Python Environment

First, let's create a new directory for our project and set up a virtual environment to keep our dependencies isolated.

mkdir joffstrends-news-aggregator
cd joffstrends-news-aggregator
python3 -m venv venv
source venv/bin/activate  # On Windows use: venv\Scripts\activate

Next, we need to install the requests library, which is the standard Python library for making HTTP requests. We will also install python-dotenv to securely manage our API key using environment variables.

pip install requests python-dotenv

Create a .env file in your root directory to store your API key securely:

JOFFSTRENDS_API_KEY=your_actual_api_key_here

Understanding the API Endpoint

The Joffstrends Search API is hosted at:
https://api.joffstrends.co.uk

To perform a search, we send a request to the search endpoint. Let's write a clean, robust Python wrapper to interact with this endpoint.

Writing the Python Script

Create a new file named aggregator.py and add the following code. This script defines a JoffstrendsClient class, handles API requests, parses the results, and implements our news aggregator logic.

import os
import json
import sys
from datetime import datetime
import requests
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

class JoffstrendsClient:
    """
    A simple Python client wrapper for the Joffstrends Search API.
    """
    BASE_URL = "https://api.joffstrends.co.uk"

    def __init__(self, api_key=None):
        # Retrieve the API key from parameters or environment variables
        self.api_key = api_key or os.getenv("JOFFSTRENDS_API_KEY")
        if not self.api_key:
            raise ValueError(
                "API Key not found. Please set JOFFSTRENDS_API_KEY in your .env file "
                "or pass it directly to the client."
            )

    def search(self, query):
        """
        Performs a search query using the Joffstrends Search API.
        """
        url = f"{self.BASE_URL}/search"
        params = {
            "q": query,
            "key": self.api_key
        }

        try:
            response = requests.get(url, params=params, timeout=10)

            # Check if the request was successful
            if response.status_code == 200:
                return response.json()
            elif response.status_code == 401:
                print("[Error] Unauthorized: Invalid API key.", file=sys.stderr)
                return None
            elif response.status_code == 429:
                print("[Error] Rate limit exceeded. Please check your plan limits.", file=sys.stderr)
                return None
            else:
                print(f"[Error] API returned status code {response.status_code}", file=sys.stderr)
                return None

        except requests.exceptions.RequestException as e:
            print(f"[Error] Network request failed: {e}", file=sys.stderr)
            return None

def save_results_to_json(query, results, filename=None):
    """
    Saves search results to a structured JSON file.
    """
    if not filename:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        safe_query = "".join(c for c in query if c.isalnum() or c in (' ', '_')).rstrip()
        safe_query = safe_query.replace(' ', '_').lower()
        filename = f"search_{safe_query}_{timestamp}.json"

    data_to_save = {
        "query": query,
        "timestamp": datetime.now().isoformat(),
        "results": results
    }

    with open(filename, 'w', encoding='utf-8') as f:
        json.dump(data_to_save, f, indent=4, ensure_ascii=False)

    print(f"\n[Success] Results successfully saved to {filename}")
    return filename

def main():
    print("=" * 60)
    print(" Joffstrends Search API - Python News Aggregator & Trend Tracker")
    print("=" * 60)

    # Initialize the client
    try:
        client = JoffstrendsClient()
    except ValueError as e:
        print(f"[Error] {e}")
        sys.exit(1)

    # Prompt user for a search query
    query = input("\nEnter search query or trend topic (e.g., 'Artificial Intelligence news'): ").strip()
    if not query:
        print("[Error] Query cannot be empty.")
        sys.exit(1)

    print(f"\nFetching real-time search results for: '{query}'...")
    results = client.search(query)

    if not results:
        print("[Error] Failed to retrieve results.")
        sys.exit(1)

    # Display results in a clean, readable format
    print("\n" + "=" * 60)
    print(f" TOP RESULTS FOR: {query.upper()}")
    print("=" * 60)

    search_items = []
    if isinstance(results, list):
        search_items = results
    elif isinstance(results, dict):
        search_items = results.get("results", results.get("items", []))
        if not search_items and "title" in results:
            search_items = [results]

    if not search_items:
        print("No search results found or unexpected response format.")
        print("Raw Response:", json.dumps(results, indent=2))
        sys.exit(0)

    for idx, item in enumerate(search_items[:10], 1):
        title = item.get("title", "No Title")
        link = item.get("link", item.get("url", "No URL"))
        snippet = item.get("snippet", item.get("description", "No description available."))

        print(f"\n[{idx}] {title}")
        print(f"    URL:  {link}")
        print(f"    Info: {snippet}")
        print("-" * 60)

    # Ask the user if they want to export the data
    export_choice = input("\nWould you like to export these results to a JSON file? (y/n): ").strip().lower()
    if export_choice == 'y':
        save_results_to_json(query, search_items)

if __name__ == "__main__":
    main()

How the Code Works

Let's break down the key components of our script:

Environment Configuration: We use python-dotenv to load the JOFFSTRENDS_API_KEY from a .env file. This is a security best practice that prevents you from accidentally hardcoding your credentials and pushing them to public repositories like GitHub.
The JoffstrendsClient Class: This class encapsulates the API logic. It constructs the correct URL (https://api.joffstrends.co.uk/search) and appends the query parameters q (your search query) and key (your API key).
Robust Error Handling: The search method handles various HTTP status codes. It alerts the developer if the key is unauthorized (401), if they have hit their rate limits (429), or if a network error occurs.
Data Normalization: Different search endpoints can return slightly different JSON structures. The script gracefully checks for common keys like results or items to ensure it can parse the output reliably.
Structured Export: The save_results_to_json function formats the output with a timestamp and saves it as a clean JSON file. This file can be easily fed into other scripts, databases, or AI pipelines.

Running the Script

To run your new aggregator, simply execute the script from your terminal:

python aggregator.py

You will be prompted to enter a search query. Try something like "Python web scraping 2026" or "latest space exploration news". The script will query the Joffstrends Search API, display the top 10 results directly in your terminal, and offer to save them to a local JSON file.

Taking It Further: AI and LLM Integration

One of the most powerful use cases for the Joffstrends Search API is Retrieval-Augmented Generation (RAG). Because the API returns clean, structured JSON, you can easily feed these results directly into an LLM (such as OpenAI's GPT-4, Anthropic's Claude, or a local Ollama model) to generate automated summaries, newsletters, or intelligence reports.

Here is a quick conceptual example of how you can pass the output of our aggregator to an LLM:

# Conceptual example of LLM integration
import openai

def generate_summary(search_results):
    # Format the search results into a clean text prompt
    context = "\n\n".join([
        f"Title: {item['title']}\nSnippet: {item['snippet']}" 
        for item in search_results
    ])

    prompt = f"Based on the following search results, write a 3-paragraph summary of the latest trends:\n\n{context}"

    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

By combining the real-time search capabilities of Joffstrends with the synthesis power of LLMs, you can build incredibly sophisticated autonomous agents and automated research tools with less than 100 lines of code.

Get Started Today

The Joffstrends Search API is the perfect companion for developers who want fast, reliable, and straightforward web search access without the enterprise price tag.

Choose the plan that fits your project needs and get your API key instantly:

Starter Plan (£4.99 one-time, 7 days access): Get Starter Plan
Monthly Plan (£9.99/month, cancel anytime): Get Monthly Plan
Annual Plan (£89.99/year, save ~3 months): Get Annual Plan

Happy coding! If you build something cool with the Joffstrends Search API, let us know in the comments below!

Joffstrends Search API: The Ultimate Developer Cheatsheet

Joffy122 — Wed, 17 Jun 2026 00:00:58 +0000

Joffstrends Search API: The Ultimate Developer Cheatsheet

Integrating web search into your applications, AI agents, or scraping pipelines shouldn't be complicated or expensive. The Joffstrends Search API offers a fast, reliable, and developer-friendly endpoint to fetch search results programmatically.

This cheatsheet serves as your quick-reference guide for authentication, endpoints, request/response formats, and multi-language integration examples.

1. Quick Start & Base URL

All requests to the Joffstrends Search API are made to the following base URL:

https://api.joffstrends.co.uk

Authentication

To use the API, you need a unique API key. You can pass this key in your request headers or as a query parameter.

Header Authentication (Recommended):

  Authorization: Bearer YOUR_API_KEY

Query Parameter Authentication:

  GET https://api.joffstrends.co.uk/search?q=query&key=YOUR_API_KEY

2. Getting an API Key

You can get an API key instantly via Gumroad. Your unique key will be emailed to you within ~1 minute of purchase:

Starter Plan: £4.99 one-time (7 days access) — Get Starter Plan
Monthly Plan: £9.99/month (1,000 searches/month, cancel anytime) — Get Monthly Plan
Annual Plan: £89.99/year (1,000 searches/month, save ~3 months) — Get Annual Plan

3. API Endpoints

`GET /search`

Retrieves search results for a given query.

Query Parameters:

Parameter	Type	Required	Description
`q`	string	Yes	The search query (must be URL-encoded).
`key`	string	No	Your API key (if not using the `Authorization` header).

4. Code Integration Examples

Here is how to integrate the Joffstrends Search API in your favorite languages and tools.

cURL

curl -X GET "https://api.joffstrends.co.uk/search?q=developer+cheatsheet" \
  -H "Authorization: Bearer YOUR_API_KEY"

Node.js (Fetch API)

const apiKey = 'YOUR_API_KEY';
const query = encodeURIComponent('developer cheatsheet');
const url = `https://api.joffstrends.co.uk/search?q=${query}`;

async function fetchSearchResults() {
  try {
    const response = await fetch(url, {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
      }
    });

    if (!response.ok) {
      throw new Error(`HTTP error! Status: ${response.status}`);
    }

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

fetchSearchResults();

Python (Requests)

import requests
import urllib.parse

api_key = "YOUR_API_KEY"
query = urllib.parse.quote("developer cheatsheet")
url = f"https://api.joffstrends.co.uk/search?q={query}"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}

try:
    response = requests.get(url, headers=headers)
    response.raise_for_status()
    results = response.json()
    print("Search Results:", results)
except requests.exceptions.RequestException as e:
    print("An error occurred:", e)

PHP (cURL)

<?php
$apiKey = 'YOUR_API_KEY';
$query = urlencode('developer cheatsheet');
$url = "https://api.joffstrends.co.uk/search?q={$query}";

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer {$apiKey}",
    "Content-Type: application/json"
]);

$response = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
} else {
    $data = json_decode($response, true);
    print_r($data);
}
curl_close($ch);
?>

5. Expected Response Format

The API returns a clean, structured JSON payload containing your search results:

{
  "query": "developer cheatsheet",
  "results": [
    {
      "title": "Developer Cheatsheets - Devhints.io",
      "link": "https://devhints.io/",
      "snippet": "A ridiculous collection of web development cheatsheets. One-page guide to everything you need to know."
    },
    {
      "title": "OverAPI.com - Collecting all cheatsheets",
      "link": "https://overapi.com/",
      "snippet": "OverAPI is a site collecting all the cheatsheets, most popular cheatsheets for developers."
    }
  ]
}

6. Best Practices & Error Handling

URL Encoding: Always URL-encode your query parameter (q) to prevent issues with special characters (e.g., spaces, &, ?).
Error Codes:
- 401 Unauthorized: Missing or invalid API key. Check your header or query parameter.
- 400 Bad Request: Missing query parameter q.
- 429 Too Many Requests: You have exceeded your plan's monthly limit.
Caching: To optimize performance and reduce API usage, cache search results locally for queries that do not require real-time updates.

Need a reliable search API for your next build? Get started with the Joffstrends Search API today!