DEV Community: api

Your Pipeline Is 11.9h Behind: Catching Software Sentiment Leads with Pulsebit

Pulsebit News Sentiment API — Tue, 12 May 2026 10:33:10 +0000

Your Pipeline Is 11.9h Behind: Catching Software Sentiment Leads with Pulsebit

We recently noticed an intriguing anomaly: a 24-hour momentum spike of -0.713 in sentiment around the topic "software." This sudden drop in momentum, coupled with the leading language being English, indicates a significant shift in sentiment that our pipelines need to address. Specifically, the English press has been leading this sentiment change by a staggering 11.9 hours. If your model isn't accounting for these nuances, it’s at risk of missing critical leads in the news cycle.

The problem here is structural. If your pipeline doesn’t effectively handle multilingual origins or entity dominance, you’re left behind. Your model missed this sentiment shift by 11.9 hours, largely due to the English-language articles dominating the conversation. The failure to recognize this lag could mean missing out on timely insights, especially when entities like software and Google are forming new narratives while mainstream discussions consolidate around established topics like "sonata" and "final dividend."

English coverage led by 11.9 hours. Et at T+11.9h. Confidence scores: English 0.85, Spanish 0.85, French 0.85 Source: Pulsebit /sentiment_by_lang.

Let’s dive into the code that can help you catch these shifts. Below is how we can use our API to specifically filter for English-language articles that discuss the topic "software":

import requests

# Define the parameters for the API call
params = {
    "topic": "software",
    "lang": "en"
}

![Left: Python GET /news_semantic call for 'software'. Right: ](https://pub-c3309ec893c24fb9ae292f229e1688a6.r2.dev/figures/g3_code_output_split_1778581988887.png)
*Left: Python GET /news_semantic call for 'software'. Right: returned JSON response structure (clusters: 3). Source: Pulsebit /news_semantic.*


# API call to fetch sentiment data
response = requests.get("https://api.pulsebit.com/sentiment", params=params)
data = response.json()

# Extract the needed values
momentum = data["momentum_24h"]  # -0.713
sentiment_score = data["sentiment_score"]  # -0.600
confidence = data["confidence"]  # 0.85

Next, we’ll run the cluster reason string through our POST /sentiment endpoint to score the narrative framing itself. This is crucial for understanding how the surrounding narrative impacts the topic:

# Prepare the input for meta-sentiment moment
meta_sentiment_input = {
    "text": "Clustered by shared themes: consolidated, sonata, software, final, dividend."
}

# API call to score the narrative framing
meta_response = requests.post("https://api.pulsebit.com/sentiment", json=meta_sentiment_input)
meta_data = meta_response.json()

# Extract the sentiment score for the meta-narrative
meta_sentiment_score = meta_data["sentiment_score"]

Now that we have the tools, here are three specific builds we can implement with this pattern:

Geographic Origin Filter: Use the geographic origin filter to query sentiment data for "software" in English. This helps in pinpointing the exact articles driving sentiment, allowing for a more focused analysis on emerging trends.

Geographic detection output for software. India leads with 2 articles and sentiment +0.12. Source: Pulsebit /news_recent geographic fields.

Meta-Sentiment Loop: Create a function to analyze the narrative framing around a group of themes. By scoring narratives around terms like "consolidated," "sonata," and "software," we can better understand the context and sentiment shifts that might not be immediately apparent from raw scores alone.
Threshold Alerts: Set up alerts for momentum changes that exceed a certain threshold. For instance, if momentum drops below -0.5, trigger a notification to your team. This will help you stay ahead of significant sentiment shifts, enabling you to react before the mainstream media catches on.

If you want to dive deeper into leveraging our API, check out our documentation at pulsebit.lojenterprise.com/docs. You can copy-paste the provided code and run it in under 10 minutes to start catching these valuable sentiment leads.

9 Essential Web Data APIs for AI Agents & Developers in 2026

ServBay — Tue, 12 May 2026 10:12:11 +0000

At this stage of AI development, the performance of Large Language Models (LLMs) heavily depends on the quality of external data input. It's a known fact that current AI can still generate false information or experience LLM hallucinations just to appear knowledgeable. But don't worry—by leveraging Web Data APIs and RAG (Retrieval-Augmented Generation), developers can equip AI with the ability to search the web, extract in-depth content, and generate evidence-based answers.

Spider: Rust-Based High-Concurrency Web Crawler API

Spider is a web scraping API built for ultimate performance. Written in Rust, it is deeply optimized specifically for AI applications. This tool supports the highly concurrent scraping of thousands of pages and can directly return cleaned Markdown or structured JSON data.

Spider's workflow is divided into three stages: crawling, processing, and delivery. It features a smart mode that automatically switches between traditional HTTP requests and headless browser rendering to balance scraping speed and success rates. For websites protected by anti-bot mechanisms, Spider integrates fingerprint spoofing and a retry engine.

Python Integration Example:

import requests, json

headers = {
    'Authorization': 'Bearer $SPIDER_API_KEY',
    'Content-Type': 'application/json',
}

json_data = {"limit": 5, "url": "https://example.com"}

response = requests.post('https://api.spider.cloud/crawl', 
                         headers=headers, stream=True)

with response as r:
    r.raise_for_status()
    for chunk in response.iter_content(chunk_size=8192):
        if chunk:
            print(json.loads(chunk.decode('utf-8')))

Firecrawl: Convert Complex Web Pages to Markdown for LLMs

Firecrawl focuses on converting web content into formats suitable for large model processing. It doesn't just scrape pages; it also supports sitemap mapping to automatically discover essential pages within a site. The tool provides a browser sandbox environment for handling interactive web tasks and supports the MCP (Model Context Protocol), making it easy to integrate into various coding assistants.

Quick Start Command:

npx -y firecrawl-cli@latest init --all --browser

Tavily: Real-Time AI Search Layer Built for Agents

Tavily API is positioned as a rapid search layer for AI models. Unlike traditional search engines, its search results are filtered and denoised, ready to be directly utilized by an AI Agent for multi-step research tasks. It offers a research API that supports deeper automated investigations, and its hosted MCP server significantly lowers configuration costs.

Integration Command:

npx skills add https://github.com/tavily-ai/skills

Apify: Modular Web Automation Platform

Apify provides a massive library of automation tools through its Actor mechanism. Its official API client supports JavaScript and TypeScript, featuring automatic retries and exponential backoff mechanisms to handle unstable network requests. It is not just a web scraper; it also manages key-value stores and datasets, making it perfect for building complex, long-term automation tasks.

Node.js Implementation:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY-APIFY-TOKEN' });

const run = await client.actor('apify/web-scraper').call({
    startUrls: [{ url: 'https://example.com' }],
    maxCrawlPages: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Exa: Neural Network-Based Semantic Search

Exa semantic search utilizes neural networks to understand the context of web content, rather than relying on simple keyword matching. This makes it highly accurate when searching for code documentation, research reports, or domain-specific news. The company research skills provided by Exa can seamlessly integrate into coding assistants, helping developers quickly acquire targeted background materials.

Python Call Example:

from exa_py import Exa
exa = Exa(api_key="your-api-key")

result = exa.search(
  "Deep blog posts about artificial intelligence",
  type="auto",
  contents={"highlights": {"max_characters": 4000}}
)

ScrapingBee: Simplified Headless Browser API

ScrapingBee encapsulates complex headless browser management into a simple API. Developers don't need to maintain Chrome instances themselves to handle JavaScript rendering and dynamically loaded content. This tool automatically manages proxy rotation and CAPTCHA bypass.

Python Integration Example:

from scrapingbee import ScrapingBeeClient

client = ScrapingBeeClient(api_key='YOUR-API-KEY')
response = client.get("https://example.com")

print('Status Code: ', response.status_code)
print('Content: ', response.content)

Bright Data: Enterprise-Grade Web Unblocker

Bright Data holds a distinct advantage when dealing with highly difficult target websites. It provides a complete web data stack, including an Unblocker API, residential proxy networks, and browser automation tools. When basic scraping tools are blocked by firewalls, its Web MCP can maintain a stable access path to bypass advanced anti-bot systems.

MCP Integration Command:

npx @brightdata/mcp

You.com: Fact-Checking Research API with Citations

You.com API provides search results with accurate citations and source proofs, which is highly effective in reducing AI hallucinations. The platform supports advanced filtered news searches and long-form content extraction. Developers can use its Agent Skills to integrate it into existing development workflows.

Add Skill Command:

npx skills add youdotcom-oss/agent-skills

Brave Search API: Independent Internet Index

Brave Search possesses a completely independent web index. It offers the AI Answers API, which can directly return summary information generated based on sources. This independence makes its search results highly competitive in terms of freshness and objectivity, providing a differentiated data perspective for AI Agents.

Install Skill Command:

npx openskills install brave/brave-search-skills

The Foundation: One-Click Local Dev Env Setup with ServBay

When actually calling the APIs mentioned above, configuring the local development environment is often the first major hurdle. Whether you are running a Python web scraping script or a Node.js automation workflow, you need a stable environment that supports multiple versions.

ServBay provides highly efficient underlying support for developers. Its core strength lies in the one-click deployment of dev environments. With this tool, developers can quickly set up a local environment that supports the coexistence of multiple versions, clearing the path for seamless API integration.

One-Click Configuration for Multi-Language Environments

For developers who need to use Python SDKs (like Exa, ScrapingBee) or Node.js SDKs (like Apify, Firecrawl), ServBay supports the one-click deployment of Python environments and Node.js environments.

Its major advantage is the ability to run multiple versions simultaneously. This means you can debug an older Node.js project and run the latest Python-based Spider scraping script on the same system without worrying about environment pollution or version conflicts. This localized environment management approach significantly boosts efficiency, from API research to product prototype construction.

Tech Stack Selection & Deployment Recommendations

The table below highlights the differences in core capabilities, environment requirements, and use cases for each tool.

Tool Name	Technical Focus	Recommended Environment	Best Use Case
Spider	High concurrency, Rust engine	Python/Rust	Large-scale parallel scraping, RAG backend
Firecrawl	Markdown conversion	Node.js	Extracting web content for AI Agents
Tavily	Agent-specific search	Python/JS	Real-time information retrieval, automated research
Apify	Modular automation flows	Node.js	Social media monitoring, complex interactive scrapers
Exa	Neural semantic search	Python	Deep research, locating professional documentation
ScrapingBee	Headless browser rendering	Python	Scraping dynamic web pages with heavy JS loading
Bright Data	Bypassing advanced anti-bots	Node.js/Python	Collecting data from highly protected commercial sites
You.com	Fact-checking & citations	REST API	Generating accurate research reports
Brave Search	Independent data index	REST API	Avoiding homogenized search results
ServBay	Environment deployment	macOS	Local multi-version Python/Node.js coexistence

Conclusion

For developers, Web Data APIs provide a window to connect with the real-time internet, while ServBay provides the local foundation to keep these tools running smoothly. In the project startup phase, it is highly recommended to use ServBay for the one-click deployment of Python and Node.js, ensuring local environment stability.

Subsequently, based on the scraping difficulty, concurrency requirements, and semantic understanding needs, select the most suitable API from the list above for integration. This development pattern—combining a solid underlying environment with powerful high-level interfaces—is the most efficient path to building high-performance AI applications.

Remove text and watermarks from any image — one API call

Om Prakash — Tue, 12 May 2026 10:00:58 +0000

Remove text and watermarks from any image — one API call

Most image-cleanup APIs make you do half the work yourself. You draw a mask, you upload the mask, you cross your fingers. We got tired of that. POST /v1/image/remove-text finds the text for you, erases it, and hands back a clean image. One call. One URL. Done.

What it does

remove-text is an auto-detect-and-erase pipeline for visible text in images. Point it at any public image URL and it segments out the text regions on its own — watermarks, captions, signage, burned-in timestamps, the corner-of-the-frame copyright text — then inpaints what was underneath using the surrounding image context. The output is the same image, minus the text, with the rest of the scene left intact.

The endpoint is POST /v1/image/remove-text. The request is JSON. The response is the cleaned image. There is nothing else to configure for the default path.

If you want finer control, three fields are exposed:

image_url — public URL of the source image. Required.
regions — an optional list of bounding boxes. Pass these if you want removal restricted to specific parts of the image instead of the whole frame. Useful when there is legitimate text you want to keep (a sign behind the subject, a label on a product) and text you want gone (a watermark over the foreground).
preserve_layout — boolean, defaults to true. With it on, the surrounding objects, edges, and structure stay where they are; the inpainting only fills the text region and blends to the local context. Turn it off only if you specifically want a freer regeneration of the masked area.

That is the whole surface. No mask uploads. No multi-step flow where you call a detection endpoint, post-process the boxes, and then call a separate inpainting endpoint. The detection and the inpainting happen on our side, in one round trip.

A few things worth being explicit about, since the FACTS block keeps me honest:

It targets visible text. Watermarks, captions, signage, timestamps — the kinds of overlays that appear in pixels, not metadata.
It works on arbitrary backgrounds. The inpainting uses surrounding context, so it handles sky, skin, fabric, asphalt, foliage — whatever happens to be behind the text.
It is built so you do not have to author the mask. That is the whole point of the detection step happening on our side.

If you have used image-cleanup tooling before, you will notice the request body is almost empty. That is deliberate.

Why we built it

Every team that ships images at scale ends up needing this. Stock-photo workflows. Archive digitization. Re-use of legacy creative. Security-footage ingestion. Marketplaces scraping seller-supplied photos. The pattern is always the same: somebody, somewhere in the pipeline, baked text into the pixels, and now you need it gone before the image moves to the next stage.

The existing options are not great. The traditional path is: run a detector, get bounding boxes, draw a mask, post the mask plus the original image to an inpainting endpoint, hope the seams match. That is two or three services, two or three round trips, and a glue layer you now own. Most rival APIs expose only the inpainting half and expect you to bring the mask. Which is fine if you are a Photoshop user doing one image. It is a problem if you are a backend.

Our angle is simple: detect and remove in one call. We run our own segmentation step on the image, build the mask from the detected text regions, and then inpaint the masked area with surrounding context — all server-side, all in the same request. You do not see the mask. You do not need to see the mask. You get the finished image back.

A few design choices fall out of that:

No mask upload path. We deliberately did not ship a "bring your own mask" mode at launch. The point of the API is that you do not need one. If you have very specific requirements about where removal can happen, that is what regions is for — coarse bounding boxes are enough to constrain the work, and far easier to author than a pixel-precise mask.
preserve_layout defaults to on. The most common failure mode of generative inpainting is that it cheerfully invents new objects in the cleared area. For text removal specifically, you almost never want that — you want the same scene, minus the text. So that is the default behavior, not an opt-in.
Single endpoint, single response. No job IDs, no polling, no callback URLs for the default case. You call it, you get the image. We host the infrastructure so you do not have to figure out batch queues for what is, conceptually, a one-shot transform.

The thing we want to make boring is the part that is usually annoying: getting a clean image out of a dirty one.

Quickstart

The minimal call is one curl. Drop your API key in, point image_url at any reachable image, and you are done.

curl -X POST https://api.pixelapi.dev/v1/image/remove-text \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image_url": "https://example.com/source.jpg"}'

Same thing in Python using requests:

import os
import requests

API_KEY = os.environ["PIXELAPI_KEY"]

resp = requests.post(
    "https://api.pixelapi.dev/v1/image/remove-text",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
    },
    json={
        "image_url": "https://example.com/source.jpg",
    },
    timeout=60,
)
resp.raise_for_status()
result = resp.json()
print(result)

That covers the default case: full-image scan, layout preserved, text gone.

If you want to scope the removal — say, you only want to clean the bottom-right corner where the timestamp lives, and you want to leave the rest of the image untouched even if there happens to be incidental text in it — pass regions:

resp = requests.post(
    "https://api.pixelapi.dev/v1/image/remove-text",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
    },
    json={
        "image_url": "https://example.com/cam-frame.jpg",
        "regions": [
            {"x": 1500, "y": 1000, "width": 380, "height": 60}
        ],
        "preserve_layout": True,
    },
    timeout=60,
)

And that is the API. There is no step three.

Use cases

Cleaning up timestamps burned into security-camera frames

If you operate any kind of CCTV or DVR pipeline, you know the problem. The camera firmware burns a timestamp directly into every frame — usually white text in a corner, sometimes with a black background block, sometimes not. The metadata is also in the file, so the burned-in copy is redundant. But the moment you want to do anything downstream — train a model on the frames, use the footage in an internal incident report, hand a snapshot to a customer — that timestamp is sitting there in the pixels and it cannot be turned off retroactively. Running each frame through remove-text with a regions box around the corner where the timestamp lives gives you a clean frame, with the rest of the scene unchanged. Wire it into your ingest path and the burned-in copy never leaves your pipeline. The metadata stays where it belongs — in the file headers — and the visual frame is yours to use.

Stripping captions off stock-photo previews you've licensed

Stock-photo workflows are full of friction. You browse, you license, you download the high-resolution version — and the licensed copy is supposed to come without the preview watermark. In practice, half the asset systems we have talked to end up with watermarked previews mixed into their working folders, either because someone grabbed a comp earlier in the process, or because a partner sent a reference file by mistake, or because the asset got cached at the preview stage and the clean version never replaced it. For images you have legitimately licensed, remove-text lets you reclaim those preview copies without re-downloading from the source. Detection handles the irregular placement of caption strips — corner, diagonal, full-frame tile — and the inpainting fills the area using whatever is around it. You end up with a usable working file from an asset you already paid for.

Erasing brand markings before re-using your own product imagery in a new campaign

Every brand team eventually hits this: a beautiful product photo from a previous campaign, where the photographer (or the agency, or the in-house designer) baked the campaign tagline or the old SKU label into the corner. Now you want to re-use the shot for a new campaign, and that old text is a non-starter. The traditional fix is a designer round-trip — open the file, clone-stamp the area, retouch the edges, save out, version, ship. For one image, fine. For two hundred, painful. remove-text handles the cleanup programmatically: point it at the originals, get back versions with the legacy markings gone, and let your designers spend their time on the new creative instead of erasing the old. With preserve_layout on, the product itself stays exactly where it was — only the text disappears.

Pricing

Pricing is per-call, flat, no tiers to negotiate.

Credits per call: 16
Price in INR: ₹0.011 per call
Price in USD: $0.00013 per call

That is the cleared-image, end-to-end price. Detection plus inpainting. No separate charge for the segmentation step. No surcharge for using the regions field. If the call succeeds, it costs 16 credits; if it fails, it does not.

At those numbers, a hundred thousand images is around ₹1,100 / $13. Most teams discover that the cost of running this in production is dwarfed by the cost of not running it — the manual cleanup hours, the back-and-forth with vendors over watermarked deliverables, the asset-management tickets that pile up because someone has to find a designer to redo a corner of a photo.

Try it

Sign in at https://pixelapi.dev/dashboard to get your API key. New accounts come with starter credits, so you can hit the endpoint with one of your own images before deciding anything.

Full reference for the request body, error codes, response format, and the regions and preserve_layout fields lives in the docs at https://pixelapi.dev/docs.

If you ship images at any kind of scale, give remove-text a real workload — a folder of timestamps, a batch of legacy product shots, a directory of licensed previews — and see what comes back. The whole point of this endpoint is that there is nothing else to learn. One URL in, one clean image out.

Google SERP API: The Smartest Way to Collect Search Results in 2026

amy — Tue, 12 May 2026 10:00:28 +0000

If you’ve ever tried scraping Google search results manually, you already know the struggle. Proxies fail, captchas appear, requests get blocked, and maintaining the scraper becomes a full-time job.

That’s exactly why developers, SEO professionals, and SaaS companies are moving toward using a Google SERP API instead.

A Google SERP API helps you collect real-time search engine result data without worrying about bans, browser automation, or constant scraper maintenance. Whether you’re tracking rankings, building an SEO tool, analysing competitors, or monitoring keywords, a SERP API makes the process faster and more reliable.

What Is a Google SERP API?

A Google SERP API is a service that returns Google search result data in structured formats like JSON or HTML. Instead of scraping Google manually, you simply send a request to the API and get clean search data instantly.

The API can provide:

Organic search results
Featured snippets
Ads data
Related searches
Local results
Shopping results
Images
News results
AI Overview data
People Also Ask sections

This makes it extremely useful for SEO tools, market research platforms, AI applications, and automation workflows.

Why Developers Prefer SERP APIs Over Traditional Scraping

Traditional scraping sounds simple until scale becomes a problem.

Here are the biggest issues developers face:

1. IP Blocks

Google aggressively blocks automated scraping requests.

2. Captchas

Even rotating proxies often trigger captcha verification.

3. Browser Costs

Running headless browsers like Puppeteer increases server costs.

4. Constant Maintenance

Google changes page structures frequently, breaking scrapers.

5. Slow Performance

Large-scale scraping requires massive infrastructure.

A SERP API solves all these problems by handling the difficult backend work for you.

Common Use Cases of Google SERP APIs

Keyword Rank Tracking

Track how websites rank for specific keywords across countries and devices.

Competitor Analysis

Monitor competitor visibility, ads, and search strategies.

AI Search Applications

Feed real-time search data into AI tools and assistants.

SEO Dashboards

Build reporting systems with live SERP insights.

Content Research

Analyse featured snippets and search intent.

E-commerce Monitoring

Track shopping results and product visibility.

Example of a Google SERP API Request

Most APIs are simple to use. Here’s a basic example in Python:


python
import requests

url = "https://api.example.com/search"

params = {
    "q": "best seo tools",
    "location": "United States",
    "device": "desktop"
}

response = requests.get(url, params=params)

print(response.json())

Within seconds, you receive structured search result data ready for analysis.

## Features to Look for in a SERP API

Not all APIs are equal. Here are some important features to consider:

### Real-Time Results

Fresh search data matters for SEO accuracy.

### Geo-Targeting

Ability to search from different countries and cities.

### Mobile & Desktop Support

Search results differ by device type.

### Fast Response Time

Speed matters when processing thousands of requests.

### JSON Output

Clean structured data saves development time.

### Scalability

The API should support high-volume requests without slowing down.

### AI Overview Support

Modern SERPs now include AI-generated summaries.

## How SERP APIs Help SEO Teams

SEO is becoming more data-driven every year. Agencies and marketers rely on SERP APIs to automate tasks that once took hours manually.

For example:

* Daily rank monitoring
* Content gap analysis
* Search intent analysis
* Featured snippet tracking
* Local SEO monitoring
* Keyword clustering

Instead of manually checking rankings, APIs allow teams to monitor thousands of keywords automatically.

## Google SERP APIs and AI Applications

AI tools need live web data to stay useful.

SERP APIs are now widely used in:

* AI chatbots
* Search assistants
* Research agents
* Trend monitoring tools
* SEO automation platforms

Without search APIs, many AI systems would struggle to provide updated information.

## Challenges to Consider

Even with APIs, there are still things to keep in mind:

### Pricing

Large-scale usage can become expensive.

### Rate Limits

Some providers limit requests per second.

### Data Accuracy

Choose providers with reliable infrastructure.

### Feature Differences

Not every provider supports all Google result types.

Testing before scaling is always a good idea.

## The Future of Search Data Collection

[Google SERP API SEO](https://www.serphouse.com/blog/3-powerful-seo-strategy-with-serp-api/) search results continue to evolve with AI-generated answers, personalised results, and interactive elements. This makes traditional scraping even harder.

SERP APIs are becoming the standard solution because they adapt faster and reduce infrastructure complexity for developers.

As SEO, AI, and automation continue growing, access to reliable search data will become even more important.

## Final Thoughts

A Google SERP API is no longer just an optional tool for SEO professionals. It has become essential for developers, marketers, AI builders, and data-driven businesses.

Instead of fighting captchas and broken scrapers, teams can focus on analyzing data and building better products.

If your project depends on search engine data, using a SERP API can save time, reduce maintenance, and scale far more efficiently than traditional scraping methods.

Implementing Idempotency with NestJS RedisX: A Practical Guide

Suren Krmoian — Tue, 12 May 2026 10:00:19 +0000

Handling duplicate requests in APIs, especially in payment systems, is a headache. NestJS RedisX offers a neat way to tackle this with its Idempotency Plugin. Let’s dig into how you can set this up.

Getting Started with Idempotency

First things first, install the necessary packages. You'll need both the core and idempotency packages of NestJS RedisX:

npm install @nestjs-redisx/core @nestjs-redisx/idempotency

Configuring the Module

To make the Idempotency Plugin work its magic, you need to configure it in your main module. This setup ensures that the plugin is ready to catch any duplicate requests globally.

import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { RedisModule } from '@nestjs-redisx/core';
import { IdempotencyPlugin } from '@nestjs-redisx/idempotency';
import { APP_INTERCEPTOR } from '@nestjs/core';
import { IdempotencyInterceptor } from '@nestjs-redisx/idempotency';

@Module({
  imports: [
    ConfigModule.forRoot(),
    RedisModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      plugins: [
        IdempotencyPlugin.registerAsync({
          imports: [ConfigModule],
          inject: [ConfigService],
          useFactory: (config: ConfigService) => ({
            defaultTtl: 86400, // 24 hours
            headerName: 'Idempotency-Key',
          }),
        }),
      ],
      useFactory: (config: ConfigService) => ({
        clients: {
          host: config.get('REDIS_HOST', 'localhost'),
          port: config.get('REDIS_PORT', 6379),
        },
      }),
    }),
  ],
  providers: [
    { provide: APP_INTERCEPTOR, useClass: IdempotencyInterceptor },
  ],
})
export class AppModule {}

Decorating Your Endpoints

Once your module is good to go, use the @Idempotent decorator on your endpoints. This ensures that each request is uniquely processed based on the Idempotency-Key.

import { Controller, Post, Body } from '@nestjs/common';
import { Idempotent } from '@nestjs-redisx/idempotency';

@Controller('payments')
export class PaymentsController {
  constructor(private readonly paymentService: PaymentService) {}

  @Post()
  @Idempotent()
  async createPayment(@Body() dto: CreatePaymentDto) {
    return this.paymentService.process(dto);
  }
}

Behind the Scenes

Here’s the lowdown: the Idempotency Plugin checks each request’s Idempotency-Key. If it’s seen the key before, it serves the cached result. No re-processing, no fuss.

Body Fingerprinting: It goes a step further by ensuring the request body’s fingerprint matches the key. This prevents using the same key for different data.
Concurrent Handling: If multiple requests with the same key pop up, the plugin handles them in sequence, avoiding any duplication.

Incorporating an idempotency layer using NestJS RedisX is pretty straightforward. It's a solid way to dodge duplicate processing in sensitive areas like payments. Want to dive deeper? Check out the official documentation.

Spring Load Limits API for Trucking Compliance

Roman Kotenko — Tue, 12 May 2026 10:00:00 +0000

Every spring, northern states and provinces impose weight restrictions on roads as frost leaves the ground. The pavement is weakest during thaw, and unrestricted heavy loads cause millions in damage.

The problem: every state publishes restrictions differently, with different dates, formats, and geographic references. Fleet operators check each state manually.

Road511 normalizes spring load limits from MN, WI, MI, ON, QC, and NS into one API with polyline geometry and active date ranges.

The Data

curl "https://api.road511.com/api/v1/features?type=weight_restrictions&jurisdiction=MN" \
  -H "X-API-Key: your_key"

{
  "data": [
    {
      "id": "mn-wr-zone3-seg12",
      "jurisdiction": "MN",
      "feature_type": "weight_restrictions",
      "name": "CSAH 5 - Frost Zone 3",
      "start_time": "2026-03-10T00:00:00Z",
      "end_time": "2026-05-15T00:00:00Z",
      "properties": {
        "restriction_type": "seasonal_weight",
        "weight_limit_tons": 5,
        "frost_zone": "Zone 3",
        "from_location": "TH 10",
        "to_location": "CSAH 12"
      }
    }
  ]
}

Each restriction has:

Polyline geometry — the exact road segment, not just a point
Start/end dates — when the restriction is active
Weight limit — in tons (MN), as a percentage reduction (MI), or by road class (WI)
Location description — from/to landmarks

Coverage

State/Province	Type	Details
Minnesota	Spring load limits	~26 segments with ton limits by frost zone
Wisconsin	Class II + Posted	148 restricted highways + 19 posted roads
Michigan	Truck Operator Route Map	~1,757 segments with 25-35% weight reductions
Ontario	Spring load limits	143 polyline segments
Quebec	Trucking network restrictions	Province-wide route restrictions
Nova Scotia	Spring weight restrictions	8,599 restricted segments

Corridor Check

Use the truck corridor endpoint to check if a planned route crosses any active restrictions:

curl "https://api.road511.com/api/v1/truck/corridor?from_lat=44.98&from_lng=-93.27&to_lat=46.87&to_lng=-96.77&buffer_km=10&weight=30" \
  -H "X-API-Key: your_key"

Minneapolis to Fargo — returns every weight restriction along the corridor that your 30-ton load would violate.

Historical Tracking

Road511 tracks when restrictions are posted and lifted via feature_history. Over multiple seasons, this data shows:

When each state typically starts/ends restrictions
Which zones get restricted first (geographic progression of thaw)
Year-over-year pattern changes

Try It

MPP TestKit - Rust SDK

MPP TestKit — Tue, 12 May 2026 09:26:24 +0000

The Rust MPP SDK (mpp-test-sdk on crates.io) implements the full Solana HTTP 402 payment flow in pure async Rust. No Solana SDK dependency. Ed25519 signing, base58, and compact-u16 transaction encoding — all from scratch with ed25519-dalek and num-bigint. Framework-agnostic server middleware via a ChargeResult enum.

Why Rust and HTTP 402?

Rust is increasingly the language of high-performance APIs, WebAssembly services, and systems that need both speed and correctness. If you're building something in Rust that serves data — and you want to charge per request without billing infrastructure — HTTP 402 on Solana is the natural fit.

The challenge is that most HTTP 402 / Solana tooling targets TypeScript or Python. The Rust MPP SDK changes that: pure Rust, async-first, no cgo, no Solana SDK, no wallet binary — just tokio, reqwest, ed25519-dalek, and the Solana JSON-RPC.

Installation

[dependencies]
mpp-test-sdk = "1.0"
tokio = { version = "1", features = ["full"] }

Client

use mpp_test_sdk::{create_test_client, TestClientConfig};

#[tokio::main]
async fn main() {
    let client = create_test_client(TestClientConfig {
        on_step: Some(Box::new(|step| {
            println!("[{:?}] {}", step.step_type, step.message);
        })),
        ..Default::default() // network: devnet, timeout: 30s
    })
    .await
    .unwrap();

    println!("Wallet: {}", client.address);

    let resp = client.fetch("http://localhost:3001/api/data", None).await.unwrap();
    let body = resp.text().await.unwrap();
    println!("{body}");
}

create_test_client generates an ed25519 keypair, airdrops 2 SOL on devnet (with 1s → 2s → 4s back-off on faucet rate limits), and returns a TestClient whose fetch method handles the entire 402 flow.

Server (framework-agnostic)

The MppServer::charge method returns a ChargeResult enum instead of directly writing to a response. This means it works with any Rust web framework — axum, actix-web, warp, hyper — without a hard dependency on any of them.

use mpp_test_sdk::{create_test_server, ChargeOptions, ChargeResult, TestServerConfig};

let server = create_test_server(TestServerConfig::default()).unwrap();
println!("Recipient: {}", server.recipient_address);

Axum

use axum::{extract::State, http::HeaderMap, response::IntoResponse, Json};
use mpp_test_sdk::{ChargeOptions, ChargeResult, MppServer};
use std::sync::Arc;

async fn data_handler(
    State(srv): State<Arc<MppServer>>,
    headers: HeaderMap,
) -> impl IntoResponse {
    let receipt = headers
        .get("payment-receipt")
        .and_then(|v| v.to_str().ok());

    match srv.charge(receipt, &ChargeOptions { amount: "0.001" }).await {
        ChargeResult::NeedsPayment { payment_request_header, body } => (
            [(
                axum::http::header::HeaderName::from_static("payment-request"),
                payment_request_header,
            )],
            axum::http::StatusCode::PAYMENT_REQUIRED,
            Json(body),
        )
            .into_response(),
        ChargeResult::Denied(reason) => {
            (axum::http::StatusCode::FORBIDDEN, reason).into_response()
        }
        ChargeResult::Authorized => {
            Json(serde_json::json!({"result": "here is your data"})).into_response()
        }
    }
}

Actix-web

use actix_web::{web, HttpRequest, HttpResponse};
use mpp_test_sdk::{ChargeOptions, ChargeResult, MppServer};
use std::sync::Arc;

async fn data_handler(
    srv: web::Data<Arc<MppServer>>,
    req: HttpRequest,
) -> HttpResponse {
    let receipt = req
        .headers()
        .get("payment-receipt")
        .and_then(|v| v.to_str().ok());

    match srv.charge(receipt, &ChargeOptions { amount: "0.001" }).await {
        ChargeResult::NeedsPayment { payment_request_header, body } => HttpResponse::PaymentRequired()
            .insert_header(("payment-request", payment_request_header))
            .json(body),
        ChargeResult::Denied(reason) => HttpResponse::Forbidden().body(reason),
        ChargeResult::Authorized => HttpResponse::Ok().json(serde_json::json!({"result": "here is your data"})),
    }
}

What happens under the hood

The SDK builds a Solana legacy transaction entirely in safe Rust:

compact-u16(1)       // signature count
[64]byte             // ed25519 signature (ed25519-dalek)
Message:
  [3]byte            // header: required_sigs=1, ro_signed=0, ro_unsigned=1
  compact-u16(3)     // account key count
  [32*3]byte         // [from, to, system_program]
  [32]byte           // recent blockhash (fetched via JSON-RPC)
  compact-u16(1)     // instruction count
  u8(2)              // program_id_index = system program
  compact-u16(2)     // account indices
  compact-u16(12)    // data length
  [4]byte LE         // SystemInstruction::Transfer = 2
  [8]byte LE         // lamports (u64)

Base58 is implemented with num-bigint. No Solana SDK. No generated code. No cgo.

Lifecycle events

use mpp_test_sdk::{create_test_client, PaymentStepType, TestClientConfig};

let client = create_test_client(TestClientConfig {
    on_step: Some(Box::new(|step| match step.step_type {
        PaymentStepType::WalletCreated => println!("Wallet: {}", step.message),
        PaymentStepType::Funded        => println!("Funded via devnet airdrop"),
        PaymentStepType::Payment       => println!("Paying: {}", step.message),
        PaymentStepType::Success       => println!("Done: {}", step.message),
        _ => {}
    })),
    ..Default::default()
})
.await
.unwrap();

Steps: WalletCreated, Funded, Request, Payment, Retry, Success, Error.

Mainnet

use mpp_test_sdk::{create_test_client, SolanaNetwork, TestClientConfig};

let client = create_test_client(TestClientConfig {
    network: Some(SolanaNetwork::Mainnet),
    secret_key: Some(my_keypair_bytes), // 32-byte seed or 64-byte keypair
    ..Default::default()
})
.await
.unwrap();

Drop-in fetch (shared wallet)

use mpp_test_sdk::mpp_fetch;

let resp = mpp_fetch("http://localhost:3001/api/data", None).await.unwrap();

Uses a lazily-created Arc<TestClient> behind a tokio::sync::Mutex, safe across tasks. Call reset_mpp_fetch().await to discard it.

Error handling

use mpp_test_sdk::Error;

match client.fetch("http://localhost:3001/api/data", None).await {
    Ok(resp) => println!("Status: {}", resp.status()),
    Err(Error::Faucet(e))   => eprintln!("Airdrop failed for {}", e.address),
    Err(Error::Payment(e))  => eprintln!("Payment failed, status: {}", e.status),
    Err(Error::Timeout(e))  => eprintln!("Timed out after {}ms", e.timeout_ms),
    Err(Error::Network(e))  => eprintln!("Network error: {}", e.network),
    Err(Error::Other(msg))  => eprintln!("Error: {msg}"),
}

Testing

#[tokio::test]
async fn test_charges_per_request() {
    use mpp_test_sdk::{create_test_client, TestClientConfig};

    // Start your axum/actix server in a background task, get port
    // ...

    let client = create_test_client(TestClientConfig::default()).await.unwrap();
    let resp = client.fetch(&format!("http://localhost:{port}/api/data"), None).await.unwrap();
    assert_eq!(resp.status().as_u16(), 200);
}

MPP TestKit - Go SDK

MPP TestKit — Tue, 12 May 2026 09:25:35 +0000

The Go MPP SDK handles the full Solana HTTP 402 payment flow with zero external dependencies. Pure stdlib: ed25519 signing, base58, JSON-RPC, and compact-u16 transaction encoding. One import, one function call on each side.

Go and HTTP 402

Go is the language of infrastructure: APIs, microservices, proxies. If you're building something that receives a lot of requests and needs to monetise them without billing overhead, Go is a natural fit.

The Go MPP SDK (github.com/mpptestkit/mpp-test-sdk-go) adds Solana-backed HTTP 402 support to any net/http handler with a single middleware call. No wallet libraries. No Solana SDK. No cgo. Pure Go standard library from crypto to JSON-RPC.

Installation

go get github.com/mpptestkit/mpp-test-sdk-go

Server

package main

import (
    "encoding/json"
    "fmt"
    "net/http"

    mpp "github.com/mpptestkit/mpp-test-sdk-go"
)

func main() {
    server, err := mpp.CreateTestServer(&mpp.TestServerConfig{
        Network: mpp.NetworkDevnet,
    })
    if err != nil {
        panic(err)
    }
    fmt.Println("Recipient:", server.RecipientAddress)

    mux := http.NewServeMux()
    mux.Handle("/api/data", server.Charge(mpp.ChargeOptions{Amount: "0.001"})(
        http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            w.Header().Set("Content-Type", "application/json")
            json.NewEncoder(w).Encode(map[string]string{"result": "here is your data"})
        }),
    ))

    http.ListenAndServe(":3001", mux)
}

server.Charge(...) returns an http.Handler middleware that fits any net/http mux, gorilla/mux, chi, or echo router.

Client

package main

import (
    "context"
    "encoding/json"
    "fmt"

    mpp "github.com/mpptestkit/mpp-test-sdk-go"
)

func main() {
    ctx := context.Background()

    client, err := mpp.CreateTestClient(ctx, &mpp.TestClientConfig{
        Network: mpp.NetworkDevnet,
        OnStep: func(step mpp.PaymentStep) {
            fmt.Printf("[%s] %s\n", step.Type, step.Message)
        },
    })
    if err != nil {
        panic(err)
    }
    fmt.Println("Wallet:", client.Address)

    resp, err := client.Fetch(ctx, "http://localhost:3001/api/data", nil)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    var result map[string]string
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Println(result) // map[result:here is your data]
}

What happens under the hood

The SDK builds a Solana legacy transaction entirely from stdlib primitives:

compact-u16(1)       // signature count
[64]byte             // ed25519 signature over message
Message:
  [3]byte            // header: required_sigs=1, ro_signed=0, ro_unsigned=1
  compact-u16(3)     // account key count
  [32*3]byte         // [from, to, system_program]
  [32]byte           // recent blockhash
  compact-u16(1)     // instruction count
  Instruction:
    u8(2)            // program_id_index = system program
    compact-u16(2)   // account indices [0=from, 1=to]
    compact-u16(12)  // data length
    [4]byte LE       // SystemInstruction::Transfer = 2
    [8]byte LE       // lamports (u64)

No Solana Go SDK. No protobuf. Just crypto/ed25519, encoding/binary, and math/big for base58.

Lifecycle steps

client, err := mpp.CreateTestClient(ctx, &mpp.TestClientConfig{
    Network: mpp.NetworkDevnet,
    OnStep: func(step mpp.PaymentStep) {
        switch step.Type {
        case mpp.StepWalletCreated:
            fmt.Println("Wallet:", step.Data["address"])
        case mpp.StepFunded:
            fmt.Println("Funded via devnet airdrop")
        case mpp.StepPayment:
            fmt.Println("Paying", step.Data["amount"], "SOL")
        case mpp.StepSuccess:
            fmt.Println("Served, status:", step.Data["status"])
        }
    },
})

Steps: wallet-created, funded, request, payment, retry, success, error.

Airdrop with exponential back-off

On devnet and testnet the SDK retries airdrop failures automatically with 1s → 2s → 4s back-off before returning MppFaucetError:

// Returns *MppFaucetError after 3 failed attempts
client, err := mpp.CreateTestClient(ctx, nil)
if err != nil {
    var faucetErr *mpp.MppFaucetError
    if errors.As(err, &faucetErr) {
        fmt.Println("Airdrop failed for:", faucetErr.Address)
    }
}

Mainnet

client, err := mpp.CreateTestClient(ctx, &mpp.TestClientConfig{
    Network:   mpp.NetworkMainnet,
    SecretKey: myKeypairBytes, // 32-byte seed or 64-byte full private key
})

Drop-in http.Get replacement

resp, err := mpp.MppFetch(ctx, "http://localhost:3001/api/data", nil)

Lazily creates a shared devnet client. Call mpp.ResetMppFetch() to force a fresh wallet.

Error types

var (
    faucetErr  *mpp.MppFaucetError
    payErr     *mpp.MppPaymentError
    timeoutErr *mpp.MppTimeoutError
    netErr     *mpp.MppNetworkError
)

switch {
case errors.As(err, &faucetErr):  fmt.Println("Airdrop failed:", faucetErr.Address)
case errors.As(err, &payErr):     fmt.Println("Payment failed, status:", payErr.Status)
case errors.As(err, &timeoutErr): fmt.Println("Timed out after:", timeoutErr.TimeoutMs, "ms")
case errors.As(err, &netErr):     fmt.Println("Network error:", netErr.Network)
}

Integration test example

func TestChargesPerRequest(t *testing.T) {
    ctx := context.Background()

    server, _ := mpp.CreateTestServer(&mpp.TestServerConfig{Network: mpp.NetworkDevnet})
    mux := http.NewServeMux()
    mux.Handle("/data", server.Charge(mpp.ChargeOptions{Amount: "0.001"})(
        http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            w.WriteHeader(http.StatusOK)
        }),
    ))
    ts := httptest.NewServer(mux)
    defer ts.Close()

    client, _ := mpp.CreateTestClient(ctx, &mpp.TestClientConfig{Network: mpp.NetworkDevnet})
    resp, err := client.Fetch(ctx, ts.URL+"/data", nil)
    if err != nil {
        t.Fatal(err)
    }
    if resp.StatusCode != http.StatusOK {
        t.Fatalf("want 200, got %d", resp.StatusCode)
    }
}

MPP TestKit - PY SDK

MPP TestKit — Tue, 12 May 2026 09:24:41 +0000

The Python MPP SDK (mpp-test-sdk on PyPI) lets you add pay-per-request billing to any Python API in minutes. No Stripe, no API keys, no billing database — just on-chain Solana payments verified server-side.

Why HTTP 402 in Python?

Python is where most ML models, data APIs, and AI services live. If you're serving embeddings, running inference, or returning processed data, you're either giving it away, hiding it behind a subscription, or building out a billing system you didn't want to build.

HTTP 402 offers a third option: charge per request, on-chain, with no infrastructure. The client pays before you serve. The server verifies on-chain. No shared secrets, no session management, no stripe webhooks.

The Python MPP SDK brings this to Flask, FastAPI, and any Python HTTP framework.

Installation

pip install mpp-test-sdk

Server (Flask)

from flask import Flask, jsonify
from mpp_test_sdk import create_test_server

app = Flask(__name__)
server = create_test_server(network="devnet")
print("Recipient:", server.recipient_address)

@app.route("/api/data")
@server.charge(amount="0.001")
def data():
    return jsonify({"result": "here is your data"})

if __name__ == "__main__":
    app.run(port=3001)

The @server.charge(amount="0.001") decorator handles everything:

Returns 402 with a Payment-Request header when no receipt is present
Verifies the Solana transaction when a Payment-Receipt header is present
Calls your handler only after payment is confirmed on-chain

Server (FastAPI)

from fastapi import FastAPI, Request
from mpp_test_sdk import create_test_server

app = FastAPI()
server = create_test_server(network="devnet")

@app.get("/api/data")
async def data(request: Request):
    result = await server.charge_async(request, amount="0.001")
    if result is not None:
        return result  # 402 or 403 response
    return {"result": "here is your data"}

Client

import asyncio
from mpp_test_sdk import create_test_client

async def main():
    client = await create_test_client(
        network="devnet",
        on_step=lambda step: print(f"[{step.type}] {step.message}"),
    )
    print("Wallet:", client.address)

    response = await client.fetch("http://localhost:3001/api/data")
    print(response.json())  # {"result": "here is your data"}

asyncio.run(main())

create_test_client generates a Solana keypair, airdrops 2 SOL on devnet automatically, and returns a client whose fetch handles the entire 402 flow.

What happens under the hood

Client                          Server
  |── GET /api/data ─────────────>|
  |<── 402 ───────────────────────|  Payment-Request: solana; amount="0.001"; recipient="9xK..."
  |                               |
  |── [build + sign Solana tx] ───|  (pure Python ed25519 signing, no wallet lib needed)
  |── [submit + confirm on-chain] |
  |                               |
  |── GET /api/data ─────────────>|  Payment-Receipt: solana; signature="3xK..."; amount="0.001"
  |                               |── [verify tx on Solana RPC]
  |<── 200 OK ────────────────────|

No third-party wallet library. The SDK builds the Solana legacy transaction wire format from scratch using standard Python cryptography.

Lifecycle callbacks

def on_step(step):
    match step.type:
        case "wallet-created": print("Wallet:", step.data["address"])
        case "funded":         print("Funded 2 SOL via devnet airdrop")
        case "payment":        print(f"Paying {step.data['amount']} SOL")
        case "success":        print("Paid and served:", step.data["status"])

client = await create_test_client(network="devnet", on_step=on_step)

Steps: wallet-created, funded, request, payment, retry, success, error.

Mainnet

client = await create_test_client(
    network="mainnet",
    secret_key=bytes(my_keypair_bytes),  # 32-byte seed or 64-byte keypair
)

No airdrop on mainnet — pass a pre-funded keypair. Everything else is identical.

Shared client (drop-in requests replacement)

from mpp_test_sdk import mpp_fetch

response = await mpp_fetch("http://localhost:3001/api/data")

Uses a lazily-created shared devnet wallet. Call reset_mpp_fetch() to force a new wallet.

Error handling

from mpp_test_sdk import MppFaucetError, MppPaymentError, MppTimeoutError

try:
    response = await client.fetch("http://localhost:3001/api/data")
except MppFaucetError as e:
    print("Airdrop failed for wallet:", e.address)
except MppPaymentError as e:
    print("Payment failed:", e.status)
except MppTimeoutError as e:
    print("Timed out after:", e.timeout_ms, "ms")

Testing your endpoint

import pytest
from mpp_test_sdk import create_test_client, create_test_server

@pytest.mark.asyncio
async def test_charges_per_request():
    server = create_test_server(network="devnet")
    # ... start your Flask/FastAPI app in a test thread
    client = await create_test_client(network="devnet")
    response = await client.fetch("http://localhost:3001/api/data")
    assert response.status_code == 200

MPP TestKit - NPM SDK

MPP TestKit — Tue, 12 May 2026 09:23:37 +0000

The TypeScript MPP SDK (mpp-test-sdk on npm) lets you build and test pay-per-request APIs on Solana in minutes. One function on the server. One function on the client. No Stripe, no database, no wallet pop-ups.

The problem with API monetisation today

Every paid API you've ever built follows the same playbook: create a Stripe account, issue API keys, build a usage-tracking database, write billing logic, handle failed payments, deal with dunning emails. You spend more time on billing infrastructure than on the API itself.

HTTP 402 was supposed to fix this. It's been reserved in the HTTP spec since 1999, sitting there with the description "Payment Required", waiting for someone to actually use it. The missing piece was always a payment layer — something fast enough to pay per request without a 3-second checkout flow.

Solana makes it possible. Sub-second finality, near-zero fees, and a simple transfer instruction. MPP wires it all together.

What MPP gives you

On the server: a single middleware that wraps any handler. When a request arrives without proof of payment, it returns a 402 with a Payment-Request header describing what to pay and where. When proof arrives, it verifies the on-chain transaction and serves the response.

On the client: a fetch replacement that detects 402, pays automatically on Solana, and retries with a Payment-Receipt header. On devnet it airdrops SOL automatically — no setup required.

Installation

npm install mpp-test-sdk

Server (Express)

import express from "express";
import { createTestServer } from "mpp-test-sdk";

const app = express();

const server = await createTestServer({ network: "devnet" });
console.log("Recipient:", server.recipientAddress);

app.get(
  "/api/data",
  server.charge({ amount: "0.001" })(async (_req, res) => {
    res.json({ result: "here is your data" });
  })
);

app.listen(3001);

That's the whole server. No billing database. No webhook handler. The middleware issues the 402 challenge and verifies the on-chain Solana transaction automatically.

Client

import { createTestClient } from "mpp-test-sdk";

const client = await createTestClient({
  network: "devnet",
  onStep: (step) => console.log(`[${step.type}] ${step.message}`),
});

console.log("Wallet:", client.address);

const res = await client.fetch("http://localhost:3001/api/data");
const data = await res.json();
console.log(data); // { result: "here is your data" }

createTestClient generates a Solana keypair, airdrops 2 SOL on devnet, and returns a client whose fetch method handles the entire 402 flow automatically.

What happens under the hood

Client                          Server
  |                               |
  |── GET /api/data ─────────────>|
  |                               |── no Payment-Receipt header
  |<── 402 Payment-Request ───────|   Payment-Request: solana; amount="0.001"; recipient="9xK..."
  |                               |
  |── [build Solana tx] ──────────|── (client signs and submits on-chain)
  |── [confirm on chain] ─────────|
  |                               |
  |── GET /api/data ─────────────>|   Payment-Receipt: solana; signature="3xK..."; amount="0.001"
  |                               |── [verify tx on-chain]
  |<── 200 OK ────────────────────|

No off-chain coordination. No shared secret. The server verifies the actual Solana transaction — recipient address, amount, confirmation status — directly via the RPC.

Lifecycle callbacks

const client = await createTestClient({
  network: "devnet",
  onStep: (step) => {
    switch (step.type) {
      case "wallet-created": console.log("Wallet:", step.data.address); break;
      case "funded":         console.log("Funded via airdrop"); break;
      case "payment":        console.log("Paying", step.data.amount, "SOL"); break;
      case "success":        console.log("Done:", step.data.status); break;
    }
  },
});

Every stage of the flow emits a typed event: wallet-created, funded, request, payment, retry, success, error.

Mainnet

import { createTestClient } from "mpp-test-sdk";

const client = await createTestClient({
  network: "mainnet",
  secretKey: Uint8Array.from(myKeypairBytes), // 32-byte seed or 64-byte keypair
});

On mainnet, no airdrop is available. Pass a pre-funded keypair. The rest of the flow is identical.

Drop-in fetch (shared wallet)

import { mppFetch } from "mpp-test-sdk";

// Uses a lazily-created shared devnet wallet
const res = await mppFetch("http://localhost:3001/api/data");

mppFetch creates a single client on the first call and reuses it. Call mppFetch.reset() to discard the wallet and force a fresh one.

Error handling

import { MppFaucetError, MppPaymentError, MppTimeoutError } from "mpp-test-sdk";

try {
  const res = await client.fetch("http://localhost:3001/api/data");
} catch (err) {
  if (err instanceof MppFaucetError)   console.error("Airdrop failed:", err.address);
  if (err instanceof MppPaymentError)  console.error("Payment failed:", err.status);
  if (err instanceof MppTimeoutError)  console.error("Timed out after:", err.timeoutMs, "ms");
}

Integration testing

The TypeScript SDK ships with a full integration test harness — spin up a server in-process, run a client against it, assert on the receipts.

import { createTestClient, createTestServer } from "mpp-test-sdk";
import express from "express";

test("charges 0.001 SOL per request", async () => {
  const server = await createTestServer({ network: "devnet" });
  const app = express();
  app.get("/data", server.charge({ amount: "0.001" })((_, res) => res.json({ ok: true })));
  const httpServer = app.listen(0);
  const { port } = httpServer.address() as { port: number };

  const client = await createTestClient({ network: "devnet" });
  const res = await client.fetch(`http://localhost:${port}/data`);
  expect(res.status).toBe(200);

  httpServer.close();
});

What's next

mpptestkit.com — interactive playground with live devnet transactions
npm: mpp-test-sdk — package
GitHub — source, issues, SDK roadmap

VoiceFleet vs Ruby Receptionist: Why Developers Are Choosing AI Phone Agents in 2026

VoiceFleet — Tue, 12 May 2026 09:05:26 +0000

VoiceFleet vs Ruby Receptionist: Why Devs Are Choosing AI Phone Agents

If you're building phone automation for a client or your own SaaS, you've probably evaluated both human answering services and AI alternatives. Here's a developer-focused breakdown of VoiceFleet vs Ruby Receptionist.

The Architecture Difference

Ruby Receptionist is fundamentally a human-in-the-loop system. Calls route to a pool of trained receptionists who follow scripts. Integration happens via webhooks that fire after a call ends — you get a payload with caller info, notes, and disposition. It works, but it's reactive.

VoiceFleet is an AI-native phone agent. It uses LLM-powered conversation with real-time speech-to-text and text-to-speech. The key difference: you can program its behaviour through a knowledge base and API integrations, not just scripts.

API & Integration Comparison

Ruby

Webhook notifications (POST after call)
Zapier integration for CRM push
No real-time API
No programmatic control over call flow

VoiceFleet

REST API for managing agents, knowledge bases, and call history
Webhook events in real-time (call.started, call.ended, appointment.booked)
Native calendar API — direct Google Calendar / Outlook sync
Custom actions — trigger external APIs mid-conversation (e.g., check inventory, look up order status)

For developers building custom workflows, VoiceFleet's API-first approach means you can embed phone reception into your product. Ruby requires manual coordination with their team for any customisation.

Latency

This matters for voice UX. Ruby's pickup time is variable (depends on available receptionists — could be 5-15 seconds). VoiceFleet picks up in <1 second consistently.

From a telephony engineering perspective, VoiceFleet's architecture eliminates the queuing problem entirely. There's no agent pool to manage — each call spawns an independent AI session.

Scaling

Need to handle 10x traffic during a product launch or seasonal spike? With Ruby, you're at the mercy of their staffing. They may not have capacity.

VoiceFleet scales horizontally by design. 10 simultaneous calls or 1,000 — same response time, same cost (€99/mo flat, unlimited).

Data & Privacy

For any developer working with EU clients, this is critical:

VoiceFleet: EU-hosted, GDPR compliant, data residency guarantees
Ruby: US-hosted, data processed under US jurisdiction

If you're building a healthcare or fintech product that handles phone calls, hosting jurisdiction matters for compliance.

Language Support

Ruby: English + Spanish.
VoiceFleet: 30+ languages with automatic detection.

If you're building a multi-tenant SaaS where each customer might serve different language demographics, VoiceFleet's polyglot capabilities save you from managing multiple answering services.

Cost at Scale

Let's say your SaaS serves 50 small businesses, each getting ~20 calls/day:

Ruby: 50 accounts × $250/mo = $12,500/mo (and they'd blow through minutes)
VoiceFleet: 50 accounts × €99/mo = €4,950/mo (unlimited)

The economics make VoiceFleet viable as an embedded feature in your product. Ruby's per-minute model makes it a cost center.

When Ruby Still Makes Sense

If your use case genuinely requires a human (legal intake with emotional sensitivity, high-stakes sales calls), Ruby's human agents are better. AI hasn't fully replaced empathy-heavy conversations yet.

TL;DR

For developers building phone automation: VoiceFleet gives you API control, predictable pricing, sub-second latency, and EU compliance. Ruby gives you humans. Choose based on your use case, but the trend is clear — programmable AI is winning.

Your Pipeline Is 13.5h Behind: Catching Real Estate Sentiment Leads with Pulsebit

Pulsebit News Sentiment API — Tue, 12 May 2026 08:55:33 +0000

Your Pipeline Is 13.5h Behind: Catching Real Estate Sentiment Leads with Pulsebit

We recently uncovered an intriguing anomaly in our data: a 24h momentum spike of -0.299 in the real estate sector. This finding stands out against the backdrop of a generally positive sentiment across various topics. The leading language here is English, with a notable cluster story titled "Costello's Ace Hardware Lease at Cedar Knolls Plaza" emerging from just one article. This highlights how even minor narratives can signal significant shifts in sentiment.

The Problem

This anomaly exposes a critical structural gap in any sentiment analysis pipeline that fails to account for multilingual origins or entity dominance. Your model missed this by 13.5 hours, lagging behind the English press narrative. The dominance of English as the leading language underscores the importance of being able to capture sentiment shifts in real time, especially when the conversation is driven by specific entities like "Costello's Ace Hardware." Without the ability to filter by language and recognize these nuances, you risk missing out on vital data that could inform your decisions.

English coverage led by 13.5 hours. Et at T+13.5h. Confidence scores: English 0.85, French 0.85, Spanish 0.85 Source: Pulsebit /sentiment_by_lang.

The Code

To catch this momentum spike, we can use our API effectively. Here's how you can query for sentiment data using Python, incorporating a geographic filter for English content:

Geographic detection output for real estate. Hong Kong leads with 2 articles and sentiment +0.77. Source: Pulsebit /news_recent geographic fields.

import requests

![Left: Python GET /news_semantic call for 'real estate'. Righ](https://pub-c3309ec893c24fb9ae292f229e1688a6.r2.dev/figures/g3_code_output_split_1778576132191.png)
*Left: Python GET /news_semantic call for 'real estate'. Right: returned JSON response structure (clusters: 3). Source: Pulsebit /news_semantic.*


# Define constants
topic = 'real estate'
score = +0.050
confidence = 0.85
momentum = -0.299
url = 'https://api.pulsebit.com/v1/sentiment'

# Step 1: Geographic origin filter for English
params = {
    'topic': topic,
    'lang': 'en'
}

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

# Print the retrieved data
print(data)

Next, we’ll run the cluster story through our sentiment endpoint to analyze the framing of the narrative itself:

# Step 2: Meta-sentiment moment
cluster_reason = "Clustered by shared themes: real, estate, arranges, 23k, lease."
sentiment_response = requests.post(url, json={"text": cluster_reason})
sentiment_data = sentiment_response.json()

# Print the sentiment analysis of the cluster reason
print(sentiment_data)

This code not only fetches the real estate sentiment data but also evaluates how the narrative is framed with respect to the emerging themes, providing a deeper understanding of sentiment shifts.

Three Builds Tonight

With this newfound insight, here are three specific builds to consider:

Spike Detection: Create a function that triggers alerts when momentum falls below a threshold of -0.25 for English topics. This ensures you catch significant drops before they filter through your data pipeline.
Cluster Sentiment Analysis: Use the meta-sentiment loop to analyze cluster narratives that have a confidence score above 0.80. This will help you refine your understanding of how different entities are framing the discussion around real estate, especially when they emerge from clusters.
Forming Themes Dashboard: Build a dashboard that visualizes forming themes like estate(+0.00), real(+0.00), and google(+0.00), comparing these against mainstream narratives. Use the geographic filter to ensure that you're only displaying English content.

Get Started

For detailed instructions on how to implement these strategies, check out our documentation at pulsebit.lojenterprise.com/docs. You can copy-paste and run the provided code in under 10 minutes to start catching sentiment leads in real time.

DEV Community: api

Your Pipeline Is 11.9h Behind: Catching Software Sentiment Leads with Pulsebit

Your Pipeline Is 11.9h Behind: Catching Software Sentiment Leads with Pulsebit

9 Essential Web Data APIs for AI Agents & Developers in 2026

Spider: Rust-Based High-Concurrency Web Crawler API

Firecrawl: Convert Complex Web Pages to Markdown for LLMs

Tavily: Real-Time AI Search Layer Built for Agents

Apify: Modular Web Automation Platform

Exa: Neural Network-Based Semantic Search

ScrapingBee: Simplified Headless Browser API

Bright Data: Enterprise-Grade Web Unblocker

You.com: Fact-Checking Research API with Citations

Brave Search API: Independent Internet Index

The Foundation: One-Click Local Dev Env Setup with ServBay

One-Click Configuration for Multi-Language Environments

Tech Stack Selection & Deployment Recommendations

Conclusion

Remove text and watermarks from any image — one API call

Remove text and watermarks from any image — one API call

What it does

Why we built it

Quickstart

Use cases

Cleaning up timestamps burned into security-camera frames

Stripping captions off stock-photo previews you've licensed

Erasing brand markings before re-using your own product imagery in a new campaign

Pricing

Try it

Google SERP API: The Smartest Way to Collect Search Results in 2026

What Is a Google SERP API?

Why Developers Prefer SERP APIs Over Traditional Scraping

1. IP Blocks

2. Captchas

3. Browser Costs

4. Constant Maintenance

5. Slow Performance

Common Use Cases of Google SERP APIs

Keyword Rank Tracking

Competitor Analysis

AI Search Applications

SEO Dashboards

Content Research

E-commerce Monitoring

Example of a Google SERP API Request

Implementing Idempotency with NestJS RedisX: A Practical Guide

Getting Started with Idempotency

Configuring the Module

Decorating Your Endpoints

Behind the Scenes

Spring Load Limits API for Trucking Compliance

The Data

Coverage

Corridor Check

Historical Tracking

Try It

MPP TestKit - Rust SDK

Why Rust and HTTP 402?

Installation

Client

Server (framework-agnostic)

Axum

Actix-web

What happens under the hood

Lifecycle events

Mainnet

Drop-in fetch (shared wallet)

Error handling

Testing

Links

MPP TestKit - Go SDK

Go and HTTP 402

Installation

Server

Client

What happens under the hood

Lifecycle steps

Airdrop with exponential back-off

Mainnet

Drop-in http.Get replacement

Error types