DEV Community: lulzasaur

Compare TCGPlayer, Reverb, and OfferUp Prices in One API Call

lulzasaur — Thu, 02 Apr 2026 11:21:08 +0000

Compare TCGPlayer, Reverb, and OfferUp Prices in One API Call

If you flip trading cards, musical gear, or general merchandise, you're probably checking multiple marketplaces manually to find the best price. TCGPlayer for Magic/Pokemon cards, Reverb for guitars and pedals, OfferUp for local deals.

I built a unified API that searches across 20+ marketplaces and returns normalized results. Here's how to build a price comparison tool in ~30 lines.

Quick Start: Cross-Marketplace Search

const API_URL = 'https://marketplace-price-api-production.up.railway.app';
const API_KEY = 'your-key';

// Search for a Fender Stratocaster across marketplaces
const markets = ['reverb', 'offerup', 'craigslist'];
const query = 'Fender Stratocaster American Professional';

const results = await Promise.all(
  markets.map(async (market) => {
    const resp = await fetch(
      `${API_URL}/${market}/search?` +
      new URLSearchParams({ q: query, limit: '5' }),
      { headers: { 'X-Api-Key': API_KEY } }
    );
    const data = await resp.json();
    return { market, listings: data.results || [] };
  })
);

// Find the cheapest listing across all marketplaces
const allListings = results.flatMap(r =>
  r.listings.map(l => ({ ...l, source: r.market }))
);

allListings
  .filter(l => l.price > 0)
  .sort((a, b) => a.price - b.price)
  .slice(0, 10)
  .forEach(l => {
    console.log(
      `$${l.price.toFixed(2)} — ${l.title.slice(0, 60)} [${l.source}]`
    );
  });

Output:

$850.00 — Fender American Professional II Stratocaster [offerup]
$899.00 — Fender Am Pro II Strat Mystic Surf Green [reverb]
$925.00 — Fender American Professional II Stratocaster HSS [craigslist]
$949.99 — Fender American Pro II Strat Dark Night [reverb]
$975.00 — Fender American Professional II Strat w/ Case [reverb]

One search query, three marketplaces, sorted by price.

Trading Card Price Comparison

For TCGPlayer, the API returns market pricing data:

const tcgResp = await fetch(
  `${API_URL}/tcg/search?` +
  new URLSearchParams({
    q: 'Charizard ex 223',
    game: 'pokemon'
  }),
  { headers: { 'X-Api-Key': API_KEY } }
);

const cards = await tcgResp.json();

for (const card of cards.results.slice(0, 5)) {
  console.log(`${card.name} — Market: $${card.marketPrice}`);
  console.log(`  Low: $${card.lowPrice} | Mid: $${card.midPrice}`);
}

Building an Arbitrage Finder

The real power is finding price gaps between marketplaces. Here's a script that checks if something is cheaper on one platform vs. another:

async function findArbitrage(query, buyFrom, sellOn) {
  const [buyResults, sellResults] = await Promise.all([
    fetch(
      `${API_URL}/${buyFrom}/search?q=${encodeURIComponent(query)}&limit=10`,
      { headers: { 'X-Api-Key': API_KEY } }
    ).then(r => r.json()),
    fetch(
      `${API_URL}/${sellOn}/search?q=${encodeURIComponent(query)}&limit=10`,
      { headers: { 'X-Api-Key': API_KEY } }
    ).then(r => r.json()),
  ]);

  const buyMin = Math.min(
    ...buyResults.results.filter(r => r.price > 0).map(r => r.price)
  );
  const sellMax = Math.max(
    ...sellResults.results.filter(r => r.price > 0).map(r => r.price)
  );

  const margin = ((sellMax - buyMin) / buyMin * 100).toFixed(1);

  if (sellMax > buyMin) {
    console.log(`💰 ${query}`);
    console.log(`   Buy on ${buyFrom}: $${buyMin.toFixed(2)}`);
    console.log(`   Sell on ${sellOn}: $${sellMax.toFixed(2)}`);
    console.log(`   Margin: ${margin}%`);
  }

  return { query, buyMin, sellMax, margin: parseFloat(margin) };
}

// Check a list of items
const items = [
  'Boss Katana 50',
  'Shure SM7B',
  'Roland TD-17',
  'Fender Jazz Bass',
];

for (const item of items) {
  await findArbitrage(item, 'offerup', 'reverb');
  await new Promise(r => setTimeout(r, 300));
}

Supported Marketplaces

The API covers 20+ marketplaces across categories:

Musical Instruments: Reverb
Trading Cards: TCGPlayer
General: OfferUp, Craigslist, Facebook Marketplace, Poshmark
Real Estate: Redfin, Realtor.com, Zillow
Cars: AutoTrader, Cars.com, CarGurus
Home Services: Thumbtack, Houzz, Angi

Each marketplace endpoint follows the same pattern: /{marketplace}/search?q=your+query. The response schema is normalized — title, price, url, image, location — so you don't need separate parsing logic per marketplace.

Price Tracking Over Time

Set up a daily cron to track prices on specific items:

import { appendFileSync } from 'fs';

const TRACK = [
  { query: 'Pokemon Charizard ex 223', market: 'tcg' },
  { query: 'Gibson Les Paul Standard', market: 'reverb' },
];

for (const item of TRACK) {
  const resp = await fetch(
    `${API_URL}/${item.market}/search?q=${encodeURIComponent(item.query)}&limit=5`,
    { headers: { 'X-Api-Key': API_KEY } }
  );
  const data = await resp.json();

  const prices = data.results
    ?.filter(r => r.price > 0)
    .map(r => r.price) || [];

  if (prices.length > 0) {
    const avg = (prices.reduce((a, b) => a + b, 0) / prices.length).toFixed(2);
    const line = `${new Date().toISOString()},${item.market},${item.query},${avg},${Math.min(...prices)},${Math.max(...prices)}`;
    appendFileSync('price-history.csv', line + '\n');
  }
}

After a few weeks, you'll have enough data points to spot trends and time your buys.

I built this because I got tired of writing scrapers every time I needed marketplace data for a project. It's on RapidAPI — free tier for evaluation, paid tiers when you're running it in production.

Build a Form 4 Insider-Buy Alert Without Parsing SEC XML

lulzasaur — Thu, 02 Apr 2026 11:20:46 +0000

Build a Form 4 Insider-Buy Alert Without Parsing SEC XML

When a public company CEO buys $500K of their own stock on the open market, that's one of the strongest conviction signals in finance. The data is public — SEC Form 4 filings — but getting it into a usable format is the hard part.

EDGAR returns XML with nested schemas, accession number lookups, and CIK-to-ticker mapping. Most people spend 3+ days just on the parser before writing any alert logic.

I needed this for trading research, so I built an API that does the EDGAR parsing and returns clean JSON. Here's how to build an insider-buy alert system in 40 lines of Python.

The Full Script

import requests
from datetime import datetime, timedelta

API_URL = "https://marketplace-price-api-production.up.railway.app"
API_KEY = "your-key"  # Free tier: 50 calls/month
HEADERS = {"X-Api-Key": API_KEY}

# Check yesterday's filings
yesterday = (datetime.now() - timedelta(days=1)).strftime("%Y-%m-%d")

# Track these tickers (or leave empty to scan all filings)
WATCHLIST = ["AAPL", "MSFT", "GOOGL", "NVDA", "AMZN", "META", "TSLA"]

alerts = []

for ticker in WATCHLIST:
    resp = requests.get(
        f"{API_URL}/sec/insider-trades",
        params={"ticker": ticker, "startDate": yesterday, "limit": 20},
        headers=HEADERS,
    )

    if resp.status_code != 200:
        continue

    for filing in resp.json().get("filings", []):
        # Get transaction details
        detail = requests.get(
            f"{API_URL}/sec/insider-trades/filing/{filing['accession']}",
            headers=HEADERS,
        ).json()

        for tx in detail.get("transactions", []):
            # Only care about open market purchases
            if tx.get("code") != "P":
                continue

            value = tx["shares"] * tx["pricePerShare"]
            if value >= 50_000:  # $50K minimum
                alerts.append({
                    "ticker": ticker,
                    "insider": detail["owner"]["name"],
                    "title": detail["owner"].get("title", ""),
                    "shares": tx["shares"],
                    "price": tx["pricePerShare"],
                    "value": value,
                    "date": tx["date"],
                })

# Print alerts
for a in sorted(alerts, key=lambda x: -x["value"]):
    print(f"🚨 {a['insider']} ({a['title']})")
    print(f"   Bought {a['shares']:,} shares of {a['ticker']}")
    print(f"   at ${a['price']:.2f} — ${a['value']:,.0f} total")
    print(f"   Filed: {a['date']}")
    print()

if not alerts:
    print("No significant insider purchases yesterday.")

Save this as insider_alerts.py and run it daily. That's it.

What the API Handles For You

Here's the work you're not doing:

CIK resolution — EDGAR identifies companies by CIK number, not ticker. The API maps AAPL → 0000320193 automatically.
Filing type filtering — EDGAR search returns 10-Ks, 8-Ks, proxies, and every other filing type. The API pre-filters to Form 4 only.
XML parsing — Form 4 filings use XBRL/XML with <nonDerivativeTransaction> and <derivativeTransaction> elements nested in complex schemas. The API flattens this to simple JSON.
Amendment handling — Form 4/A filings amend previous filings. The API deduplicates and returns the latest version.
Rate limiting — SEC throttles at 10 req/sec and requires a User-Agent header with contact info. The API handles the SEC-side rate limits.

Filtering by Transaction Type

Form 4 transaction codes tell you what happened:

Code	Meaning	Why It Matters
P	Open market purchase	The signal — insider buying with own money
S	Open market sale	Could be a 10b5-1 plan or discretionary
A	Award/grant	Compensation, ignore for trading signals
M	Option exercise	Converting options, often paired with S
F	Tax withholding	Automatic, not a decision

Focus on P codes. When a CFO buys $200K of stock on the open market — not an option exercise, not a grant — they're making a bet with personal money.

Adding Slack/Discord Alerts

Wire it to your team channel:

import json
from urllib.request import Request, urlopen

WEBHOOK_URL = "https://hooks.slack.com/services/YOUR/WEBHOOK/URL"

if alerts:
    blocks = []
    for a in alerts[:5]:
        blocks.append({
            "type": "section",
            "text": {
                "type": "mrkdwn",
                "text": (
                    f"*{a['insider']}* ({a['title']})\n"
                    f"Bought {a['shares']:,} shares of *{a['ticker']}* "
                    f"at ${a['price']:.2f} — *${a['value']:,.0f}*"
                )
            }
        })

    payload = {"text": "Insider Buy Alerts", "blocks": blocks}
    req = Request(WEBHOOK_URL, json.dumps(payload).encode(),
                  {"Content-Type": "application/json"})
    urlopen(req)

What the Research Says

Academic studies (Lakonishok & Lee 2001, Jeng et al. 2003) consistently show insider purchases outperform the market by 7-10% annualized. The strongest signals:

Cluster buys — multiple insiders buying within a week
Large purchases — $100K+ relative to the insider's compensation
CEO/CFO buys — officers have better information than board members

This script catches all three patterns. You can extend the filtering to flag cluster buys by grouping alerts by ticker.

I vibe coded this API for my own portfolio research. It's on RapidAPI — free tier to evaluate, paid tiers when you're running it in production daily.

Verify Contractor Licenses in 11 US States with One API Call

lulzasaur — Thu, 02 Apr 2026 11:20:21 +0000

Verify Contractor Licenses in 11 US States with One API Call

If you build anything in insurance tech, background checks, credentialing, or construction management, you've probably hit this wall: verifying a contractor's license means scraping 11 different state websites, each with different formats, search flows, and data schemas.

California uses CSLB. Texas has TDLR. Florida runs DBPR. Washington has L&I with 159K+ records. New York uses municipal open data. None of them agree on what a "license record" looks like.

I needed this for a compliance project, so I built a single API that normalizes all of it.

The Problem

Here's what you're dealing with state by state:

State	Agency	Records	Format
CA	CSLB	300K+	HTML scraping
TX	TDLR	200K+	Search form
FL	DBPR	500K+	HTML table
NY	NYC Open Data	80K+	JSON API
WA	L&I (Socrata)	159K	JSON API
CT	DCP	133K	Socrata
OR	CCB	56K	Includes bond/insurance
CO	DORA	70K	Trade licenses
IL	IDFPR	400K+	Statewide
IA	DWD	17K	Socrata
DE	DPOS	31K	Socrata

Each state returns different fields. Some include bond info, some include insurance, some just give you name + license number + status. Building scrapers for each one is a multi-week project.

One Endpoint, Normalized Response

const response = await fetch(
  'https://marketplace-price-api-production.up.railway.app/license/search?' +
  new URLSearchParams({
    state: 'CA',
    name: 'Johnson Electric',
    type: 'contractor'
  }),
  { headers: { 'X-Api-Key': 'your-key' } }
);

const data = await response.json();

{
  "success": true,
  "total": 3,
  "licenses": [
    {
      "name": "JOHNSON ELECTRIC INC",
      "licenseNumber": "C10-987654",
      "state": "CA",
      "status": "Active",
      "type": "C-10 Electrical",
      "issueDate": "2015-03-12",
      "expirationDate": "2027-03-31",
      "bond": {
        "amount": 25000,
        "company": "Hartford Fire Insurance"
      }
    }
  ]
}

Every state returns the same shape: name, license number, status, type, dates. States that have bond/insurance data include it. The normalization layer handles the differences so your code doesn't have to.

Building a Bulk Verification Pipeline

The real use case is batch verification. Here's a Node.js script that checks a CSV of contractors against all supported states:

import { parse } from 'csv-parse/sync';
import { readFileSync, writeFileSync } from 'fs';

const API_URL = 'https://marketplace-price-api-production.up.railway.app/license/search';
const API_KEY = 'your-key';

const contractors = parse(readFileSync('contractors.csv'), {
  columns: true
});

const results = [];

for (const row of contractors) {
  const resp = await fetch(
    `${API_URL}?${new URLSearchParams({
      state: row.state,
      name: row.company_name,
      type: 'contractor'
    })}`,
    { headers: { 'X-Api-Key': API_KEY } }
  );

  const data = await resp.json();
  const match = data.licenses?.[0];

  results.push({
    company: row.company_name,
    state: row.state,
    verified: match?.status === 'Active',
    licenseNumber: match?.licenseNumber || 'NOT FOUND',
    expiration: match?.expirationDate || 'N/A'
  });

  // Respect rate limits
  await new Promise(r => setTimeout(r, 200));
}

writeFileSync('verification-results.json', JSON.stringify(results, null, 2));
console.log(`Verified ${results.length} contractors`);

Feed it a CSV with company_name and state columns, get back verification status for each one.

Expiration Monitoring

Set up a daily cron to catch licenses about to expire:

const WATCHLIST = [
  { name: 'ABC Plumbing', state: 'FL', license: 'CFC1234567' },
  { name: 'XYZ Electric', state: 'CA', license: 'C10-987654' },
];

for (const contractor of WATCHLIST) {
  const resp = await fetch(
    `${API_URL}?state=${contractor.state}&license=${contractor.license}`,
    { headers: { 'X-Api-Key': API_KEY } }
  );
  const data = await resp.json();
  const lic = data.licenses?.[0];

  if (lic) {
    const daysLeft = Math.floor(
      (new Date(lic.expirationDate) - Date.now()) / 86400000
    );
    if (daysLeft < 30) {
      console.log(
        `⚠️ ${contractor.name} (${contractor.state}) ` +
        `expires in ${daysLeft} days`
      );
    }
  }
}

Why Not Just Scrape?

You could build scrapers for each state. I did — that's how this API started. Here's why you probably don't want to maintain them:

California CSLB changes their HTML layout every few months
Florida DBPR rate-limits aggressively and blocks automated UA strings
Oregon CCB includes bond/insurance data nested in secondary pages
Washington L&I uses Socrata with non-obvious dataset IDs

Each state breaks differently, at different times. I handle the maintenance so you don't have to.

I built this because I kept needing it across projects. It's on RapidAPI — free tier gives you enough calls to evaluate, paid tiers for production volume.

Monitor Insider Trading Without Parsing SEC XML — Form 4 Data as Clean JSON

lulzasaur — Wed, 01 Apr 2026 16:22:39 +0000

Monitor Insider Trading Without Parsing SEC XML — Form 4 Data as Clean JSON

SEC Form 4 filings are one of the most useful public datasets for tracking what company insiders (CEOs, directors, 10% owners) are doing with their stock. When a CEO buys 50,000 shares of their own company, that's a signal.

The problem: getting this data from SEC EDGAR is genuinely painful.

The EDGAR Problem

EDGAR serves filings as nested XML/SGML documents. There's no proper REST API for structured Form 4 data. Here's what you're dealing with:

CIK-based lookups: You need to map ticker symbols to CIK numbers (EDGAR's internal ID system)
Full-text search returns everything: Searching for "AAPL" returns all 100+ filing types — 10-Ks, 8-Ks, proxies — not just insider trades
XML parsing: Form 4 filings use XBRL/XML with nested schemas. The actual transaction data is buried inside <nonDerivativeTransaction> and <derivativeTransaction> elements
No pagination or filtering: EDGAR's XBRL feeds dump everything. You build the filtering logic

Most developers spend 2-3 days just getting the XML parsing right before they can extract a single transaction.

Skip the XML

I built an API that does all the EDGAR parsing and returns clean JSON. Here's what a Form 4 query looks like:

curl "https://your-api/sec/insider-trades?ticker=AAPL&limit=5"

{
  "success": true,
  "total": 1542,
  "filings": [
    {
      "accession": "0000950123-26-001456",
      "filedDate": "2026-03-31",
      "periodOfReport": "2026-03-27",
      "insider": {
        "name": "Cook Timothy D",
        "cik": "0001234567"
      },
      "company": {
        "name": "APPLE INC",
        "cik": "0000320193"
      }
    }
  ]
}

Get full transaction details for any filing:

curl "https://your-api/sec/insider-trades/filing/0000950123-26-001456"

{
  "issuer": {
    "cik": "0000320193",
    "name": "APPLE INC",
    "ticker": "AAPL"
  },
  "owner": {
    "name": "Cook Timothy D",
    "isDirector": true,
    "isOfficer": true,
    "title": "Chief Executive Officer"
  },
  "transactions": [
    {
      "security": "Common Stock",
      "date": "2026-03-25",
      "code": "P",
      "codeLabel": "Purchase",
      "shares": 50000,
      "pricePerShare": 178.50,
      "sharesAfter": 3500000,
      "ownership": "direct"
    }
  ]
}

Ticker-based search (no CIK mapping needed), pre-filtered to Form 4 only, transactions parsed into flat JSON.

Building an Insider Trading Monitor

Here's a Python script that checks for insider purchases above $100K:

import requests
from datetime import datetime, timedelta

API_URL = "https://your-api/sec/insider-trades"
API_KEY = "your-api-key"
WATCHLIST = ["AAPL", "MSFT", "GOOGL", "AMZN", "TSLA"]

headers = {"X-Api-Key": API_KEY}
yesterday = (datetime.now() - timedelta(days=1)).strftime("%Y-%m-%d")

for ticker in WATCHLIST:
    resp = requests.get(
        API_URL,
        params={"ticker": ticker, "startDate": yesterday},
        headers=headers,
    )
    data = resp.json()

    for filing in data.get("filings", []):
        # Get full transaction details
        detail = requests.get(
            f"{API_URL}/filing/{filing['accession']}",
            headers=headers,
        ).json()

        for tx in detail.get("transactions", []):
            if tx["code"] == "P":  # Purchase
                value = tx["shares"] * tx["pricePerShare"]
                if value > 100_000:
                    print(
                        f"🚨 {detail['owner']['name']} "
                        f"({detail['owner'].get('title', 'Insider')}) "
                        f"bought {tx['shares']:,} shares of {ticker} "
                        f"at ${tx['pricePerShare']:.2f} "
                        f"(${value:,.0f} total)"
                    )

Run this on a daily cron and you've got an insider trading alert system. The code is ~30 lines because all the hard work (XML parsing, CIK resolution, filing filtering) is handled by the API.

Transaction Codes Explained

Form 4 transactions use single-letter codes:

Code	Meaning	Signal
P	Open market purchase	Bullish — insider buying with own money
S	Open market sale	Could be planned (10b5-1) or discretionary
A	Grant/award	Compensation, not a market signal
M	Option exercise	Converting options to shares
F	Tax withholding	Automatic, not discretionary
G	Gift	Estate planning, not a trading signal

The most interesting transactions are P (purchases) and S (sales) — these represent discretionary decisions by insiders.

What You'd Build Without This

For context, here's what the DIY version looks like:

Build a CIK-to-ticker mapping table (SEC provides a bulk file, ~13,000 companies)
Write an EDGAR full-text search query parser
Build XML/SGML parsers for Form 4 documents (two different schemas depending on filing date)
Handle XBRL footnotes, amendments (Form 4/A), and derivative transactions
Implement rate limiting (SEC throttles to 10 req/sec with a required User-Agent header)
Build storage and deduplication logic

That's a week of work minimum, plus ongoing maintenance when EDGAR changes their schema.

I vibe coded this for my own trading research. It's on RapidAPI — free tier if you want to poke around.

I Replaced 5 State Website Scrapers with One API Call

lulzasaur — Wed, 01 Apr 2026 16:22:17 +0000

I Replaced 5 State Website Scrapers with One API Call

If you've ever had to verify a contractor or nurse license, you know the pain. Each state has its own website, its own search form, its own output format. California's CSLB looks nothing like Texas's TDLR, which looks nothing like Florida's DBPR.

I was building a compliance tool for a staffing platform and kept writing throwaway scrapers for each state. After the third one broke because a state board redesigned their site, I just built an API that normalizes all of them.

Here's the before/after.

The Manual Way (Per State)

For California contractors, you'd go to the CSLB site, fill out a form, parse the HTML response. For Texas, it's TDLR with a completely different flow. Florida? DBPR, another UI.

Each state takes 5-10 minutes to look up manually. If you're verifying 50 contractors for a construction company, that's 4+ hours of tab-switching.

And if you're doing it programmatically? You need a separate scraper for each state, each with its own selectors, error handling, and maintenance burden.

The API Way

One REST call, same JSON schema regardless of state:

curl "https://your-api/contractor-license/verify?state=CA&licenseNumber=1096738"

{
  "results": [
    {
      "state": "CA",
      "licenseNumber": "1096738",
      "businessName": "Pacific Construction Inc",
      "personName": "John Smith",
      "licenseStatus": "Active",
      "licenseType": "General Building Contractor",
      "expirationDate": "2026-12-31",
      "city": "Los Angeles"
    }
  ],
  "count": 1,
  "processingMs": 4523
}

Same call for Texas:

curl "https://your-api/contractor-license/verify?state=TX&name=Smith"

Same JSON schema. Same field names. No per-state logic in your app.

Nurse Licenses Too

The same API handles nurse credential verification:

curl "https://your-api/nurse-license/verify?state=FL&lastName=Johnson"

{
  "results": [
    {
      "state": "FL",
      "licenseNumber": "RN9876543",
      "personName": "Sarah Johnson",
      "licenseStatus": "Active - Clear",
      "licenseType": "Registered Nurse",
      "expirationDate": "2027-04-30"
    }
  ]
}

This matters for healthcare staffing platforms and credentialing departments that need to verify both trade licenses (contractors, electricians) and healthcare credentials (nurses, therapists) — normally two completely separate verification workflows.

Time Savings Breakdown

Task	Manual	API
Single license lookup	5-10 min	3-5 sec
50 contractor verifications	4+ hours	2 minutes (batch)
Adding a new state	Build new scraper (days)	Already supported
Handling site redesign	Fix broken scraper	API maintainer handles it

The real value isn't the individual lookup speed — it's the maintenance burden. State websites change their markup regularly. Someone has to keep those scrapers working.

Building a Compliance Workflow

Here's a simple Node.js script that checks license status for a list of contractors:

const contractors = [
  { state: 'CA', licenseNumber: '1096738' },
  { state: 'TX', name: 'Smith Construction' },
  { state: 'FL', licenseNumber: 'CBC1234567' },
];

const results = await Promise.all(
  contractors.map(async (c) => {
    const params = new URLSearchParams(c);
    const res = await fetch(
      `https://your-api/contractor-license/verify?${params}`,
      { headers: { 'X-Api-Key': process.env.API_KEY } }
    );
    return res.json();
  })
);

const expired = results
  .flatMap(r => r.results)
  .filter(r => r.licenseStatus !== 'Active');

if (expired.length > 0) {
  console.log('⚠️ Expired/inactive licenses:', expired);
  // Send alert to compliance team
}

Runs on a daily cron, alerts your team when anything expires. Total code: ~20 lines.

What States Are Supported?

Currently: California (CSLB), Texas (TDLR), Florida (DBPR), and New York (NYC Open Data) for contractors. Florida (DOH) and New York (NYSED) for nurses.

More states are being added — the normalization layer means new states slot in without changing your integration code.

I built this because I needed it for my own projects. It's on RapidAPI if you want to try it — free tier included.

Build a Price Comparison Tool in 15 Minutes with the Marketplace Price API

lulzasaur — Wed, 01 Apr 2026 06:04:29 +0000

Ever tried to find the best price for something across multiple marketplaces? You'd need to open OfferUp, Poshmark, Reverb, TCGPlayer — each with different search interfaces and no way to compare side by side.

The Marketplace Price API solves this with a single unified /search endpoint that queries multiple marketplaces simultaneously and returns normalized results.

In this tutorial, we'll build a CLI price comparison tool in under 15 minutes.

What We're Building

A Node.js script that:

Takes a search query as input
Searches across 4 marketplaces in parallel
Shows a sorted comparison table with the best prices

Prerequisites

Node.js 18+
A free RapidAPI account (sign up here)

Step 1: Get Your API Key

Subscribe to the Marketplace Price Tracker API on RapidAPI. The free tier gives you 500 requests/month — plenty for this tutorial.

Copy your X-RapidAPI-Key from the API dashboard.

Step 2: Set Up the Project

mkdir price-compare && cd price-compare
npm init -y

Create a .env file:

RAPIDAPI_KEY=your_key_here

Step 3: Build the Comparison Tool

Create compare.mjs:

const API_KEY = process.env.RAPIDAPI_KEY;
const BASE = "https://marketplace-price-tracker.p.rapidapi.com";
const HEADERS = {
  "X-RapidAPI-Key": API_KEY,
  "X-RapidAPI-Host": "marketplace-price-tracker.p.rapidapi.com",
};

const query = process.argv[2];
if (!query) {
  console.error("Usage: node compare.mjs <search query>");
  process.exit(1);
}

console.log(`\nSearching for "${query}" across 4 marketplaces...\n`);

// Search all marketplaces in parallel
const endpoints = [
  { name: "Reverb", path: `/reverb/search?query=${encodeURIComponent(query)}&limit=5` },
  { name: "TCGPlayer", path: `/tcg/search?query=${encodeURIComponent(query)}&limit=5` },
  { name: "OfferUp", path: `/offerup/search?query=${encodeURIComponent(query)}&limit=5` },
  { name: "Poshmark", path: `/poshmark/search?query=${encodeURIComponent(query)}&limit=5` },
];

const results = await Promise.allSettled(
  endpoints.map(async ({ name, path }) => {
    const res = await fetch(`${BASE}${path}`, { headers: HEADERS });
    if (!res.ok) return { name, items: [] };
    const data = await res.json();
    const items = (data.results || data.listings || []).map((item) => ({
      marketplace: name,
      title: item.title || item.productName || item.name,
      price: parseFloat(item.price || item.marketPrice || item.lowestPrice || 0),
      condition: item.condition || "N/A",
      url: item.url || "#",
    }));
    return { name, items };
  })
);

// Flatten and sort by price
const allItems = results
  .filter((r) => r.status === "fulfilled")
  .flatMap((r) => r.value.items)
  .filter((item) => item.price > 0)
  .sort((a, b) => a.price - b.price);

if (allItems.length === 0) {
  console.log("No results found. Try a different search term.");
  process.exit(0);
}

// Display results
console.log("Price".padEnd(10) + "Marketplace".padEnd(14) + "Condition".padEnd(12) + "Title");
console.log("-".repeat(80));

for (const item of allItems.slice(0, 20)) {
  const price = `$${item.price.toFixed(2)}`.padEnd(10);
  const mp = item.marketplace.padEnd(14);
  const cond = (item.condition || "N/A").slice(0, 10).padEnd(12);
  const title = item.title?.slice(0, 44) || "—";
  console.log(`${price}${mp}${cond}${title}`);
}

console.log(`\nFound ${allItems.length} results across ${results.filter((r) => r.status === "fulfilled").length} marketplaces`);

Step 4: Run It

RAPIDAPI_KEY=your_key_here node compare.mjs "fender stratocaster"

Output:

Searching for "fender stratocaster" across 4 marketplaces...

Price     Marketplace   Condition   Title
--------------------------------------------------------------------------------
$149.99   OfferUp       Good        Fender Squier Stratocaster Electric Gui
$225.00   Poshmark      N/A         Fender Player Stratocaster HSS Buttercr
$349.00   Reverb        Excellent   Fender Player Stratocaster 2019 3-Color
$425.00   Reverb        Very Good   Fender American Stratocaster Sunburst
$599.99   Reverb        Excellent   Fender American Pro II Stratocaster
...

Found 18 results across 4 marketplaces

Available Endpoints

Endpoint	Description
`GET /reverb/search`	Reverb music gear listings
`GET /reverb/price-history`	Historical price data for Reverb items
`GET /tcg/search`	TCGPlayer card listings
`GET /tcg/price`	TCGPlayer card price lookup
`GET /offerup/search`	OfferUp local marketplace listings
`GET /poshmark/search`	Poshmark fashion resale listings

Use Cases

Resellers: Find arbitrage opportunities across marketplaces
Collectors: Track TCG card prices, find the best deals on vintage gear
Shoppers: Compare prices before buying
Discord Bots: Power price-check commands with real-time data
Price Tracking Apps: Build dashboards with historical pricing

What's Next?

Add a simple web UI with React or Svelte
Store historical prices in SQLite for trend analysis
Set up a cron job to check prices daily
Build a Discord bot with /price-check commands

The Marketplace Price Tracker API free tier includes 500 requests/month — enough to build and test any of these.

Verify Professional Licenses Across US States with a Single API Call

lulzasaur — Wed, 01 Apr 2026 06:04:09 +0000

If you've ever tried to verify a professional license, you know the pain. Each state has its own licensing board, its own website, its own search interface. California's CSLB looks nothing like Texas's TDLR. Florida's DBPR has a completely different form than New York's DOB.

The Healthcare License Verification API normalizes all of this into a single REST endpoint. One call, any state, any profession.

Who Needs This

Staffing agencies verifying nurse credentials before placement
Background check companies automating license verification at scale
HR/compliance teams validating healthcare worker licenses
Credentialing platforms automating provider onboarding
Telemedicine companies verifying cross-state licensing

If you're doing any of this manually today — searching state websites one by one — this is the API for that.

How It Works

Healthcare Provider Lookup

Query by state, name, and license type. Results come from NPPES (the national provider database):

curl -G "https://healthcare-license.p.rapidapi.com/healthcare/verify" \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "X-RapidAPI-Host: healthcare-license.p.rapidapi.com" \
  -d "state=CA" \
  -d "lastName=Johnson" \
  -d "licenseType=RN"

Response:

{
  "success": true,
  "count": 3,
  "source": "NPPES",
  "state": "CA",
  "licenseType": "RN",
  "results": [
    {
      "npi": "1234567890",
      "firstName": "Jane",
      "lastName": "Johnson",
      "licenseType": "RN",
      "taxonomyDescription": "Registered Nurse",
      "state": "CA",
      "city": "San Francisco",
      "credentials": "RN"
    }
  ]
}

Contractor License Verification

Verify contractor licenses across CA, TX, FL, and NY:

curl -G "https://healthcare-license.p.rapidapi.com/contractor-license/verify" \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "X-RapidAPI-Host: healthcare-license.p.rapidapi.com" \
  -d "state=CA" \
  -d "licenseNumber=1234567"

Response includes license status, expiration, bonding info:

{
  "success": true,
  "results": [
    {
      "state": "CA",
      "source": "CSLB",
      "licenseNumber": "1234567",
      "businessName": "ABC Construction Inc",
      "licenseStatus": "Active",
      "licenseType": "B - General Building",
      "expirationDate": "2027-03-31"
    }
  ]
}

Supported Professions

22 healthcare license types across all 50 states via NPPES:

Code	Profession
MD / DO	Medical Doctor / Osteopathy
RN / LPN / NP / APRN	Nursing
PA	Physician Assistant
PT / PTA / OT / OTA	Therapy
RPH / PHARMD	Pharmacy
DDS / DMD	Dentistry
PSYCH / DC / OD / DPM	Specialists

Plus contractor and nurse verification with direct state board data.

Build a Batch Verification Script

const RAPIDAPI_KEY = process.env.RAPIDAPI_KEY;
const BASE = "https://healthcare-license.p.rapidapi.com";
const HEADERS = {
  "X-RapidAPI-Key": RAPIDAPI_KEY,
  "X-RapidAPI-Host": "healthcare-license.p.rapidapi.com"
};

async function verifyProvider(state, lastName, licenseType) {
  const params = new URLSearchParams({ state, lastName, licenseType });
  const res = await fetch(`${BASE}/healthcare/verify?${params}`, {
    headers: HEADERS
  });
  return res.json();
}

const providers = [
  { state: "CA", lastName: "Smith", licenseType: "RN" },
  { state: "TX", lastName: "Garcia", licenseType: "MD" },
  { state: "FL", lastName: "Williams", licenseType: "NP" },
];

for (const p of providers) {
  const result = await verifyProvider(p.state, p.lastName, p.licenseType);
  const count = result.count || 0;
  console.log(`${p.state} | ${p.licenseType} | ${p.lastName}: ${count > 0 ? "FOUND" : "NOT FOUND"} (${count} records)`);
}

Python Example

import requests
import os

def verify_license(state, last_name, license_type):
    return requests.get(
        "https://healthcare-license.p.rapidapi.com/healthcare/verify",
        headers={
            "X-RapidAPI-Key": os.environ["RAPIDAPI_KEY"],
            "X-RapidAPI-Host": "healthcare-license.p.rapidapi.com"
        },
        params={"state": state, "lastName": last_name, "licenseType": license_type}
    ).json()

result = verify_license("CA", "Johnson", "RN")
print(f"Found {result['count']} results")
for r in result.get("results", [])[:3]:
    print(f"  {r['firstName']} {r['lastName']} — {r['city']}, {r['state']}")

Also available as installable packages:

npm install license-verify-api   # JavaScript
pip install license-verifier      # Python

Use Cases in Production

Staffing Agencies: Verify nurse credentials are active before placement. One API call replaces 10 minutes of manual board searching.

Background Checks: Add license verification as a step in your pipeline. Structured JSON — no scraping or PDF parsing.

Credentialing: Provider credentialing takes 90-120 days. Automating the license check cuts days off.

Compliance Dashboards: Monitor license expiration dates for your entire staff. Alert before they expire.

Available Endpoints

Method	Endpoint	Description
GET	`/healthcare/verify`	Search by state, name, license type
GET	`/healthcare/npi/:npi`	Direct NPI lookup
GET	`/contractor-license/verify`	Contractor license search
GET	`/nurse-license/verify`	Nurse license search

Subscribe on RapidAPI — free tier available. Paid tiers from $9.99/month.

Add Persistent Memory to Your AI Agent in 5 Minutes

lulzasaur — Wed, 01 Apr 2026 06:03:48 +0000

Most AI agents forget everything the moment their session ends. You can fix that with a single API call.

The Agent Memory API gives any AI agent persistent, searchable memory through a REST interface. No vector database. No Redis cluster. No infrastructure to manage. Just HTTP requests.

Here's how to wire it into your agent in 5 minutes.

The Problem

You're building an AI agent — maybe with LangChain, CrewAI, or a custom loop. It works great in a single session. But restart it and... blank slate. Every conversation starts from zero.

The usual fixes:

Vector databases (Pinecone, Weaviate) — overkill for structured state, expensive, complex setup
Redis — fast but ephemeral, no search, another service to manage
File storage — no concurrency, no search, doesn't scale

What you actually want: a simple key-value store with namespaces, search, and automatic cleanup.

What We're Building

A Python agent helper that stores and retrieves memories across sessions:

from agent_memory import AgentMemory

memory = AgentMemory(namespace="customer-support-bot")

# Store a memory
memory.store("user_123_prefs", {
    "name": "Sarah",
    "timezone": "America/New_York",
    "preferred_tone": "casual"
})

# Retrieve it later (even after restart)
prefs = memory.get("user_123_prefs")
print(prefs["value"]["name"])  # "Sarah"

# Search across all memories
results = memory.search("casual tone")

Step 1: Get Your API Key

Subscribe to the Agent Memory API on RapidAPI. The free tier gives you requests to get started.

Copy your X-RapidAPI-Key from the dashboard.

Step 2: Build the Memory Client

Create agent_memory.py:

import requests
import json
import os

class AgentMemory:
    def __init__(self, namespace, api_key=None):
        self.namespace = namespace
        self.base_url = "https://agent-memory-api.p.rapidapi.com"
        self.headers = {
            "X-RapidAPI-Key": api_key or os.environ["RAPIDAPI_KEY"],
            "X-RapidAPI-Host": "agent-memory-api.p.rapidapi.com",
            "Content-Type": "application/json"
        }

    def store(self, key, value, ttl_seconds=None, metadata=None):
        """Store a memory. Value can be any JSON-serializable object."""
        payload = {
            "namespace": self.namespace,
            "key": key,
            "value": json.dumps(value) if not isinstance(value, str) else value,
        }
        if ttl_seconds:
            payload["ttl_seconds"] = ttl_seconds
        if metadata:
            payload["metadata"] = metadata

        resp = requests.post(
            f"{self.base_url}/v1/memories",
            headers=self.headers,
            json=payload
        )
        resp.raise_for_status()
        return resp.json()

    def get(self, key):
        """Retrieve a specific memory by key."""
        resp = requests.get(
            f"{self.base_url}/v1/memories/{self.namespace}/{key}",
            headers=self.headers
        )
        if resp.status_code == 404:
            return None
        resp.raise_for_status()
        result = resp.json()
        try:
            result["value"] = json.loads(result["value"])
        except (json.JSONDecodeError, TypeError):
            pass
        return result

    def search(self, query, limit=10):
        """Full-text search across all memories in this namespace."""
        resp = requests.post(
            f"{self.base_url}/v1/memories/{self.namespace}/search",
            headers=self.headers,
            json={"query": query}
        )
        resp.raise_for_status()
        return resp.json().get("results", [])

    def delete(self, key):
        """Delete a specific memory."""
        resp = requests.delete(
            f"{self.base_url}/v1/memories/{self.namespace}/{key}",
            headers=self.headers
        )
        resp.raise_for_status()
        return resp.json()

    def list_all(self, limit=50):
        """List all memories in this namespace."""
        resp = requests.get(
            f"{self.base_url}/v1/memories/{self.namespace}",
            headers=self.headers,
            params={"limit": limit}
        )
        resp.raise_for_status()
        return resp.json()

Step 3: Wire It Into Your Agent

Here's a practical example — a support agent that remembers user preferences across sessions:

import os
from agent_memory import AgentMemory

memory = AgentMemory(
    namespace="support-agent-v1",
    api_key=os.environ["RAPIDAPI_KEY"]
)

def handle_message(user_id, message):
    user_ctx = memory.get(f"user_{user_id}")

    if user_ctx:
        print(f"Welcome back, {user_ctx['value']['name']}!")
        context = user_ctx["value"]
    else:
        context = {"name": "there", "interactions": 0}

    response = process_with_llm(message, context)

    context["interactions"] = context.get("interactions", 0) + 1
    context["last_message"] = message
    memory.store(f"user_{user_id}", context)

    return response

Step 4: Add Searchable Knowledge

The API includes full-text search powered by SQLite FTS5:

memory.store(
    "learning_001",
    "Users in EST timezone prefer morning follow-ups",
    metadata={"category": "scheduling", "confidence": 0.85}
)

memory.store(
    "learning_002",
    "Billing questions resolve faster with screenshot evidence",
    metadata={"category": "billing", "confidence": 0.92}
)

# Search for relevant knowledge
results = memory.search("billing")
for r in results:
    print(f"  {r['key']}: {r['value']}")

Step 5: Automatic Cleanup with TTL

For temporary state, set a TTL so memories auto-expire:

# Expires in 1 hour — no cron jobs needed
memory.store(
    "session_abc123",
    {"step": 3, "form_data": {"email": "user@example.com"}},
    ttl_seconds=3600
)

Why Not a Vector Database?

Feature	Agent Memory API	Vector DB (Pinecone, etc.)
Setup time	5 minutes	30+ minutes
Exact retrieval	Yes (key-based)	No (approximate)
Full-text search	Yes (FTS5)	Needs separate index
Cost	Free tier available	$70+/month
Auto-expiry (TTL)	Built-in	Manual cleanup

For agent state — preferences, conversation history, learned rules — you want exact, predictable retrieval. Not something semantically similar.

Available Endpoints

Method	Endpoint	Description
POST	`/v1/memories`	Store a memory
POST	`/v1/memories/batch`	Store up to 100
GET	`/v1/memories/:namespace`	List namespace
GET	`/v1/memories/:namespace/:key`	Get specific
PUT	`/v1/memories/:namespace/:key`	Update
DELETE	`/v1/memories/:namespace/:key`	Delete
POST	`/v1/memories/:namespace/search`	Full-text search
GET	`/v1/stats`	Usage statistics

The Agent Memory API free tier is enough to prototype. Paid tiers start at $9.99/month for production workloads.

Build a Marketplace Arbitrage Finder in 50 Lines of JavaScript

lulzasaur — Tue, 31 Mar 2026 23:30:23 +0000

Build a Marketplace Arbitrage Finder in 50 Lines of JavaScript

I flip stuff on the side. Not full-time — more like "I check prices when I'm bored and occasionally make $50 on a guitar pedal someone underpriced on Reverb."

The tedious part was always manually searching the same item across multiple platforms. So I wrote a script that does it for me. It checks TCGPlayer and Reverb, compares prices, and spits out anything with a meaningful price gap.

Here's the whole thing.

The Idea

Price arbitrage = same item listed at different prices on different platforms. A Boss DS-1 pedal for $35 on Reverb might be $55 on eBay. A Charizard card listed at $12 on one platform might sell for $20 on another.

The trick is finding those gaps before everyone else does.

Setup

You need Node.js and a RapidAPI key (free tier works for testing).

mkdir arbitrage-finder && cd arbitrage-finder
npm init -y
npm install node-fetch

Create a .env file:

RAPIDAPI_KEY=your_key_here

The Script

Here's find-deals.mjs — the whole thing:

import fetch from 'node-fetch';

const RAPIDAPI_KEY = process.env.RAPIDAPI_KEY;
const RAPIDAPI_HOST = 'marketplace-price-tracker.p.rapidapi.com';

const headers = {
  'x-rapidapi-key': RAPIDAPI_KEY,
  'x-rapidapi-host': RAPIDAPI_HOST,
};

async function searchReverb(query) {
  const url = `https://${RAPIDAPI_HOST}/reverb/search?query=${encodeURIComponent(query)}&limit=10`;
  const res = await fetch(url, { headers });
  const data = await res.json();
  return (data.results || []).map(item => ({
    title: item.title,
    price: parseFloat(item.price?.amount || 0),
    platform: 'Reverb',
    url: item.url,
  }));
}

async function searchTCG(query) {
  const url = `https://${RAPIDAPI_HOST}/tcg/search?query=${encodeURIComponent(query)}&limit=10`;
  const res = await fetch(url, { headers });
  const data = await res.json();
  return (data.results || []).map(item => ({
    title: item.name || item.title,
    price: parseFloat(item.marketPrice || item.price || 0),
    platform: 'TCGPlayer',
    url: item.url,
  }));
}

async function findArbitrage(query, minGapPercent = 20) {
  console.log(`\nSearching: "${query}"\n`);

  const [reverbResults, tcgResults] = await Promise.all([
    searchReverb(query),
    searchTCG(query),
  ]);

  const allListings = [...reverbResults, ...tcgResults]
    .filter(item => item.price > 0)
    .sort((a, b) => a.price - b.price);

  if (allListings.length < 2) {
    console.log('Not enough listings to compare.');
    return;
  }

  const lowest = allListings[0];
  const highest = allListings[allListings.length - 1];
  const gap = ((highest.price - lowest.price) / lowest.price) * 100;

  console.log(`Lowest:  $${lowest.price.toFixed(2)} on ${lowest.platform}`);
  console.log(`Highest: $${highest.price.toFixed(2)} on ${highest.platform}`);
  console.log(`Gap:     ${gap.toFixed(1)}%\n`);

  if (gap >= minGapPercent) {
    console.log(`🔥 DEAL: Buy on ${lowest.platform} → sell on ${highest.platform}`);
    console.log(`   Potential profit: $${(highest.price - lowest.price).toFixed(2)}`);
  } else {
    console.log('No significant arbitrage found.');
  }
}

// Run it
const query = process.argv[2] || 'Boss DS-1';
findArbitrage(query);

Running It

RAPIDAPI_KEY=your_key node find-deals.mjs "Charizard Base Set"

Output looks like:

Searching: "Charizard Base Set"

Lowest:  $12.50 on TCGPlayer
Highest: $24.99 on Reverb
Gap:     99.9%

🔥 DEAL: Buy on TCGPlayer → sell on Reverb
   Potential profit: $12.49

Making It Useful

The basic version above is a starting point. Here's how I actually use it:

1. Batch search from a watchlist:

const watchlist = [
  'Boss DS-1',
  'MXR Phase 90',
  'Ibanez Tube Screamer',
  'Pokemon Base Set Booster',
  'Charizard VMAX',
];

for (const item of watchlist) {
  await findArbitrage(item, 15);
  await new Promise(r => setTimeout(r, 1000)); // rate limit
}

2. Run on a cron:

# Check every 6 hours
0 */6 * * * cd /path/to/arbitrage-finder && node find-deals.mjs "Boss DS-1" >> deals.log

3. Add more marketplaces:

The same API also has endpoints for OfferUp, Poshmark, eBay, Mercari, and a bunch of others. Same pattern — just swap the route:

// Same headers, different endpoint
const url = `https://${RAPIDAPI_HOST}/offerup/search?query=${query}`;

What I Learned

Timing matters more than price gaps. A 30% gap means nothing if the item takes 3 months to sell.
Condition is everything. "Used - Good" on one platform might be "Fair" on another. Always check photos.
Shipping eats profits. Factor in $5-15 shipping per flip before getting excited about a $10 gap.
The real edge is speed. Underpriced items get snatched fast. Running this on a cron and checking results on your phone is the actual workflow.

The API

I built the marketplace search API for my own flipping workflow. It's on RapidAPI with a free tier (50 requests/month) if you want to try it: Marketplace Price Tracker.

Supports 20+ marketplaces. The whole thing runs on Apify actors behind a Railway backend — I wrote about the architecture in a previous post.

If you've got a better arbitrage strategy or want to add a marketplace I'm missing, drop a comment.

Add Tamper-Proof Audit Logs to Your AI Agent in 10 Minutes

lulzasaur — Sat, 28 Mar 2026 03:34:18 +0000

Add Tamper-Proof Audit Logs to Your AI Agent in 10 Minutes

If you're building AI agents that make decisions, call tools, or interact with users, you need an audit trail. Not just logs — a cryptographically verifiable chain that proves no entries were modified or deleted after the fact.

This matters for compliance, debugging, and trust. When your agent makes a $10,000 trading decision or sends an email on behalf of a user, you need to prove exactly what happened and that the record hasn't been tampered with.

I built an audit log API with HMAC chain verification specifically for AI agents. Every log entry is cryptographically linked to the previous one — if anyone modifies a single entry, the chain breaks and verification fails.

How HMAC Chain Verification Works

Each log entry gets an HMAC (Hash-based Message Authentication Code) computed from:

The entry's content (agent_id, action, details, outcome)
The previous entry's HMAC
A server-side secret key

This creates a chain where every entry depends on all previous entries. Modify entry #50 and entries #51 through #1000 all fail verification. It's the same principle behind blockchain, but without the overhead.

Entry 1: HMAC(content_1 + "genesis")     → hmac_1
Entry 2: HMAC(content_2 + hmac_1)        → hmac_2
Entry 3: HMAC(content_3 + hmac_2)        → hmac_3
...
Tamper entry 2? → hmac_2 changes → hmac_3 invalid → chain broken

Quick Start: Log Your First Agent Action

import requests

API_URL = "https://agent-audit-log-api-production.up.railway.app"

# Log an agent action
response = requests.post(f"{API_URL}/v1/logs", json={
    "agent_id": "trading-bot-001",
    "action": "tool_call",
    "details": {
        "tool": "execute_trade",
        "ticker": "AAPL",
        "shares": 100,
        "price": 185.50,
        "side": "buy"
    },
    "outcome": "success"
})

entry = response.json()
print(f"Logged: {entry['id']}")
print(f"HMAC: {entry['hmac']}")
print(f"Sequence: {entry['entry_sequence']}")

That's it. One POST request and you have a tamper-proof audit entry. The API handles HMAC computation, chain linking, and storage.

Supported Action Types

The API is flexible about what you log. Common patterns:

# Session lifecycle
requests.post(f"{API_URL}/v1/logs", json={
    "agent_id": "support-agent-42",
    "action": "session_start",
    "details": {"user_id": "usr_abc123", "channel": "slack"},
    "outcome": "success"
})

# Tool calls
requests.post(f"{API_URL}/v1/logs", json={
    "agent_id": "support-agent-42",
    "action": "tool_call",
    "details": {"tool": "search_knowledge_base", "query": "refund policy"},
    "outcome": "success"
})

# Decisions
requests.post(f"{API_URL}/v1/logs", json={
    "agent_id": "support-agent-42",
    "action": "decision",
    "details": {
        "decision": "escalate_to_human",
        "reason": "Customer requesting account deletion",
        "confidence": 0.92
    },
    "outcome": "success"
})

# Errors
requests.post(f"{API_URL}/v1/logs", json={
    "agent_id": "support-agent-42",
    "action": "error",
    "details": {"error": "API timeout", "retry_count": 3},
    "outcome": "failure"
})

Supported entry types: tool_call, tool_result, decision, action, error, session_start, session_end, memory, agent_action, agent_finish, llm_start, llm_end.

Verify Chain Integrity

The whole point of HMAC chains is verification. One call tells you if the audit trail is intact:

# Verify the chain for an agent
verify = requests.post(f"{API_URL}/v1/verify", json={
    "agent_id": "trading-bot-001"
})

result = verify.json()
print(f"Chain intact: {result['valid']}")
print(f"Chain length: {result['chain_length']}")
print(f"Errors: {result['errors']}")

If valid is true, every entry in the chain is unmodified since creation. If it's false, the response tells you exactly where the chain broke.

JavaScript Integration

const API_URL = "https://agent-audit-log-api-production.up.railway.app";

class AuditLogger {
  constructor(agentId) {
    this.agentId = agentId;
  }

  async log(action, details, outcome = "success") {
    const res = await fetch(`${API_URL}/v1/logs`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        agent_id: this.agentId,
        action,
        details,
        outcome
      })
    });
    return res.json();
  }

  async verify() {
    const res = await fetch(`${API_URL}/v1/verify`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ agent_id: this.agentId })
    });
    return res.json();
  }

  async getHistory(limit = 50) {
    const res = await fetch(
      `${API_URL}/v1/logs?agent_id=${this.agentId}&limit=${limit}`
    );
    return res.json();
  }
}

// Usage
const audit = new AuditLogger("my-agent-001");

await audit.log("session_start", { user: "alice", channel: "api" });
await audit.log("tool_call", { tool: "web_search", query: "weather NYC" });
await audit.log("decision", { response: "Current temp is 72F", model: "gpt-4" });
await audit.log("session_end", { messages: 3, duration_ms: 4500 });

// Verify nothing was tampered with
const integrity = await audit.verify();
console.log(`Chain valid: ${integrity.valid} (${integrity.chain_length} entries)`);

LangChain Integration

If you're using LangChain, you can drop in an audit callback that automatically logs every LLM call, tool use, and agent decision:

from langchain.callbacks.base import BaseCallbackHandler
import requests

class AuditLogCallback(BaseCallbackHandler):
    def __init__(self, agent_id, api_url):
        self.agent_id = agent_id
        self.api_url = api_url

    def _log(self, action, details, outcome="success"):
        requests.post(f"{self.api_url}/v1/logs", json={
            "agent_id": self.agent_id,
            "action": action,
            "details": details,
            "outcome": outcome
        })

    def on_llm_start(self, serialized, prompts, **kwargs):
        self._log("llm_start", {"model": serialized.get("name", "unknown")})

    def on_llm_end(self, response, **kwargs):
        self._log("llm_end", {
            "tokens": response.llm_output.get("token_usage", {}) if response.llm_output else {}
        })

    def on_tool_start(self, serialized, input_str, **kwargs):
        self._log("tool_call", {"tool": serialized.get("name"), "input": input_str[:500]})

    def on_tool_end(self, output, **kwargs):
        self._log("tool_result", {"output": str(output)[:500]})

    def on_agent_finish(self, finish, **kwargs):
        self._log("agent_finish", {"output": finish.return_values.get("output", "")[:500]})


# Drop into any LangChain agent
from langchain.agents import initialize_agent

audit = AuditLogCallback(
    agent_id="langchain-agent-001",
    api_url="https://agent-audit-log-api-production.up.railway.app"
)

agent = initialize_agent(tools, llm, callbacks=[audit])
agent.run("What's the weather in NYC?")
# Every LLM call, tool use, and decision is now audit-logged with HMAC verification

Why Not Just Use CloudWatch / Datadog / Regular Logs?

Regular logging systems are designed for debugging. They're mutable — anyone with admin access can edit or delete entries. That's fine for application logs, but not for audit trails where the integrity of the record matters.

The HMAC chain gives you:

Tamper evidence: Any modification is immediately detectable
Non-repudiation: You can prove an action happened (or didn't)
Compliance: Meets audit trail requirements for regulated industries
Agent-native: Built specifically for the log-every-action pattern of AI agents

Use Cases

Financial agents: Log every trade decision with full context. Prove to regulators exactly what information the agent had when it made a decision.

Customer support bots: Track every response and escalation. When a customer disputes what the bot said, you have a verifiable record.

Healthcare AI: Document every recommendation and data access. HIPAA requires audit trails for systems accessing patient data.

Autonomous coding agents: Log every file edit, test run, and deployment. When something breaks, trace exactly what the agent did.

Multi-agent systems: Each agent gets its own chain. Verify individual agent behavior independently.

Try It

The API is live:

Direct endpoint: agent-audit-log-api-production.up.railway.app
RapidAPI (managed auth + usage tracking): Agent Audit Log on RapidAPI

Free tier gives you 1,000 entries/month — enough to instrument a prototype agent end to end.

Verify Professional Licenses via API — Contractors, Nurses, and Healthcare Providers

lulzasaur — Sat, 28 Mar 2026 03:33:58 +0000

Verify Professional Licenses via API — Contractors, Nurses, and Healthcare Providers

If you're building a platform that connects people with licensed professionals — contractors, nurses, doctors — you eventually hit the same problem: how do you verify their license is real and active?

Every state has its own licensing board with its own website, its own search interface, and its own data format. California's contractor board returns different fields than Florida's. New York's nurse lookup works completely differently from Texas.

I built an API that unifies all of this behind a single REST interface. One call, structured JSON, real-time data from official state sources.

The Problem With Manual Verification

A typical home services marketplace needs to verify contractor licenses. Here's what that looks like without an API:

User claims license #1096738 in California
Your team manually goes to cslb.ca.gov
Searches for the license number
Copies the status, expiration date, business name
Repeat for every contractor, in every state, on every renewal

At scale, this is untenable. And if you're in healthcare, the stakes are even higher — you're verifying that the nurse or doctor treating patients actually has a valid license.

Quick Start: Verify a Contractor License

import requests

API_URL = "https://license-verify-api-production.up.railway.app"

# Verify a California contractor license
response = requests.get(f"{API_URL}/contractor/verify", params={
    "state": "CA",
    "licenseNumber": "1096738"
})

data = response.json()
result = data["results"][0]

print(f"Business: {result['businessName']}")
print(f"Status: {result['licenseStatus']}")
print(f"Type: {result['licenseType']}")
print(f"Expires: {result['expirationDate']}")
print(f"Source: {result['source']}")  # "CSLB"

Output:

Business: NOOR ELECTRIC
Status: Active
Type: General Building Contractor
Expires: 09/30/2026
Source: CSLB

The API hits the actual California State Licensing Board and returns real-time data. Not a cached copy — the actual current status.

Supported States & Search Types

Contractors (4 states):

CA — California State Licensing Board (CSLB)
TX — Texas Department of Licensing and Regulation (TDLR)
FL — Florida DBPR
NY — NYC Department of Buildings + Consumer Affairs

Nurses (2 states):

FL — Department of Health MQA
NY — NYSED Office of the Professions

Healthcare Professionals (50 states + DC):

22 profession types: MD, DO, RN, LPN, NP, PA, PT, OT, RPH, DDS, and more
Uses NPPES NPI Registry for nationwide coverage
Deep verification via official state boards in FL

You can search by license number, name, or business name:

# Search by person name
response = requests.get(f"{API_URL}/contractor/verify", params={
    "state": "FL",
    "lastName": "Smith",
    "firstName": "John",
    "maxResults": 5
})

# Search by business name
response = requests.get(f"{API_URL}/contractor/verify", params={
    "state": "TX",
    "businessName": "ABC Construction"
})

Healthcare Verification (50 States)

The healthcare endpoint covers all 50 states through the NPI Registry, with deep verification in Florida:

# Verify a doctor in any state via NPI
response = requests.get(f"{API_URL}/healthcare/verify", params={
    "state": "CA",
    "lastName": "Smith",
    "licenseType": "MD",
    "maxResults": 10
})

data = response.json()
for doc in data["results"]:
    print(f"Dr. {doc['personName']} — {doc['taxonomyDescription']}")
    print(f"   NPI: {doc['npiNumber']} | Status: {doc['status']}")
    print(f"   Location: {doc['city']}, {doc['state']}")

# Direct NPI lookup (instant)
npi_resp = requests.get(f"{API_URL}/healthcare/npi/1234567890")

Supported profession types:

Category	Types
Nursing	RN, LPN, NP, APRN, CNA
Medicine	MD, DO, PA
Therapy	PT, PTA, OT, OTA, SLP
Pharmacy	RPH, PHARMD
Dental	DDS, DMD
Other	DC, OD, DPM, PSYCH

JavaScript Example: Build a Verification Form

const API_URL = "https://license-verify-api-production.up.railway.app";

async function verifyContractor(state, licenseNumber) {
  const params = new URLSearchParams({ state, licenseNumber });
  const res = await fetch(`${API_URL}/contractor/verify?${params}`);
  const data = await res.json();

  if (data.count === 0) {
    return { verified: false, message: "License not found" };
  }

  const license = data.results[0];
  return {
    verified: license.licenseStatus === "Active",
    business: license.businessName,
    status: license.licenseStatus,
    type: license.licenseType,
    expires: license.expirationDate,
    source: license.source,
    processingMs: data.processingMs
  };
}

// Usage
const result = await verifyContractor("CA", "1096738");
if (result.verified) {
  console.log(`License verified: ${result.business} (${result.status})`);
} else {
  console.log(`License invalid or not found`);
}

Batch Verification

For platforms processing multiple verifications at once, the batch endpoint handles up to 50 concurrent lookups:

import requests

API_URL = "https://license-verify-api-production.up.railway.app"

# Verify multiple licenses in one call
response = requests.post(f"{API_URL}/batch", json={
    "verifications": [
        {"type": "contractor", "state": "CA", "licenseNumber": "1096738"},
        {"type": "contractor", "state": "FL", "licenseNumber": "CBC1263939"},
        {"type": "nurse", "state": "FL", "licenseNumber": "RN766302"},
        {"type": "healthcare", "state": "NY", "lastName": "Smith", "licenseType": "MD"}
    ]
})

data = response.json()
print(f"Processed {data['total']} verifications in {data['processingMs']}ms")

for result in data["results"]:
    status = "PASS" if result["count"] > 0 else "NOT FOUND"
    print(f"  [{result['index']}] {status} — {result['count']} results")

Practical Use Cases

Home services platforms: Verify contractors before allowing them to bid on jobs. Auto-flag expired licenses. Show verified badges to homeowners.

Healthcare staffing: Validate nurse credentials during onboarding. Run periodic re-checks for license renewals. Cross-reference NPI numbers.

Insurance underwriting: Confirm active licenses before issuing professional liability policies. Batch-verify during annual renewals.

Background checks: Add license verification as a data point alongside criminal records and employment history.

Compliance automation: Scheduled checks that alert when a provider's license status changes from Active to Expired/Suspended.

Data Sources

All data comes from official government sources — state licensing boards and the federal NPPES registry. Nothing is scraped from aggregator sites. Response times are typically 2-5 seconds for individual lookups (the API queries the source in real-time).

Each response includes a source field so you know exactly which authority provided the data, and a processingMs field for performance monitoring.

Try It

Direct endpoint: license-verify-api-production.up.railway.app
RapidAPI: License Verify API on RapidAPI
Check supported states: GET /contractor/states and GET /nurse/states

Free tier gets you 50 requests/day — enough to prototype and test.

How I Built an SEC Insider Trading Alert System With 3 API Calls

lulzasaur — Sat, 28 Mar 2026 03:33:36 +0000

How I Built an SEC Insider Trading Alert System With 3 API Calls

Every public company insider — CEOs, CFOs, board members — is legally required to report stock trades to the SEC within two business days via Form 4 filings. That's 200+ filings per day, all public data, and it's one of the most reliable trading signals available.

I built an API that polls EDGAR, parses the XML, and returns clean JSON. Here's how to use it to build a real-time insider trading alert system.

Why Insider Trades Matter

Academic research consistently shows that insider purchases outperform the market by 7-10% annually. When a CEO buys $2M of their own stock on the open market, they're putting personal money where their mouth is. That's a signal worth tracking.

The problem: SEC EDGAR returns raw XML/SGML documents designed for regulators, not developers. Parsing Form 4 filings means dealing with accession numbers, CIK lookups, and XML namespaces.

The API handles all of that and returns structured JSON.

Quick Start: Get Recent Insider Trades

The simplest call — fetch the latest insider trades across all companies:

import requests

API_URL = "https://sec-edgar-insider-alerts-production.up.railway.app"

# Get recent insider trades (last 3 days)
response = requests.get(f"{API_URL}/sec/insider-trades", params={
    "days": 3,
    "limit": 20
})

data = response.json()
print(f"Found {data['total']} filings")

for filing in data["filings"]:
    print(f"{filing['filedDate']} | {filing['insider']['name']} | {filing['company']['name']}")

Output:

Found 847 filings
2026-03-27 | Tim Cook | Apple Inc.
2026-03-27 | Jensen Huang | NVIDIA Corp
2026-03-26 | Satya Nadella | Microsoft Corporation
...

Filter by Company Ticker

Want to monitor a specific stock? Use the company endpoint:

# Get all AAPL insider trades in the last 30 days
aapl = requests.get(f"{API_URL}/sec/insider-trades/company/AAPL", params={
    "days": 30,
    "limit": 50
})

data = aapl.json()
print(f"AAPL insider trades: {data['total']}")

for filing in data["filings"]:
    insider = filing["insider"]["name"]
    date = filing["filedDate"]
    print(f"  {date} — {insider}")

This covers 10,400+ ticker symbols — basically every public company on EDGAR.

Get Full Transaction Details

The filing detail endpoint is where it gets interesting. Each Form 4 contains the actual transaction data — shares bought/sold, price per share, and post-transaction holdings:

# Get full Form 4 details
detail = requests.get(
    f"{API_URL}/sec/insider-trades/filing/0002114927-26-000005"
)

filing = detail.json()
print(f"Insider: {filing['owner']['name']}")
print(f"Company: {filing['issuer']['name']} ({filing['issuer']['ticker']})")
print(f"Role: Director={filing['owner']['isDirector']}, Officer={filing['owner']['isOfficer']}")

for tx in filing["transactions"]:
    action = tx["codeLabel"]  # "Purchase", "Sale", "Option Exercise"
    shares = tx["shares"]
    price = tx.get("pricePerShare", "N/A")
    print(f"  {action}: {shares} shares @ ${price}")

Response includes:

Transaction codes: P (Purchase), S (Sale), M (Option Exercise), G (Gift), A (Grant)
Insider roles: Director, Officer (with title), 10% Owner
Both non-derivative and derivative transactions (options, warrants)
Post-transaction holdings so you can see their total position

Build a Simple Alert Bot

Here's a practical example — a script that checks for large insider purchases and sends alerts:

import requests

API_URL = "https://sec-edgar-insider-alerts-production.up.railway.app"
WATCHLIST = ["AAPL", "MSFT", "GOOGL", "NVDA", "TSLA", "META", "AMZN"]
MIN_VALUE = 100000  # Alert on purchases over $100K

def check_insider_buys():
    alerts = []

    for ticker in WATCHLIST:
        resp = requests.get(f"{API_URL}/sec/insider-trades/company/{ticker}", params={
            "days": 1,
            "limit": 20
        })
        data = resp.json()

        for filing in data.get("filings", []):
            # Get full details to check transaction value
            detail = requests.get(f"{API_URL}{filing['detailUrl']}")
            info = detail.json()

            for tx in info.get("transactions", []):
                if tx["code"] == "P":  # Open market purchase
                    value = (tx.get("shares", 0) or 0) * (tx.get("pricePerShare", 0) or 0)
                    if value >= MIN_VALUE:
                        alerts.append({
                            "ticker": ticker,
                            "insider": info["owner"]["name"],
                            "shares": tx["shares"],
                            "value": value,
                            "date": tx["date"]
                        })

    return alerts

# Run it
buys = check_insider_buys()
for buy in buys:
    print(f"🚨 {buy['ticker']}: {buy['insider']} bought {buy['shares']} shares (${buy['value']:,.0f})")

JavaScript Version (Node.js)

const API_URL = "https://sec-edgar-insider-alerts-production.up.railway.app";

// Fetch recent insider trades
async function getInsiderTrades(ticker, days = 7) {
  const res = await fetch(
    `${API_URL}/sec/insider-trades/company/${ticker}?days=${days}&limit=50`
  );
  const data = await res.json();

  return data.filings.map(f => ({
    date: f.filedDate,
    insider: f.insider.name,
    company: f.company.name,
    detailUrl: f.detailUrl
  }));
}

// Get transaction details
async function getFilingDetail(accession) {
  const res = await fetch(`${API_URL}/sec/insider-trades/filing/${accession}`);
  return res.json();
}

// Example: Find all purchases in NVDA this month
const trades = await getInsiderTrades("NVDA", 30);
console.log(`Found ${trades.length} NVDA insider filings`);

for (const trade of trades.slice(0, 5)) {
  console.log(`${trade.date} — ${trade.insider}`);
}

Use Cases

Trading signals: Cluster analysis on insider buys (3+ insiders buying within a week is historically bullish)
Compliance dashboards: Monitor executive trading windows and blackout periods
Financial research: Backtest insider sentiment vs. stock performance
Slack/Discord bots: Push alerts when specific insiders trade
Portfolio screening: Filter your holdings by recent insider activity

Data Source & Reliability

The API pulls directly from SEC EDGAR's EFTS API and ATOM feed — official government data, not scraped from third-party sites. Polling happens every 5 minutes during market hours, with fallback to the ATOM feed if EFTS is down.

Covers all Form 4 filers across NYSE, NASDAQ, and OTC markets. No rate limiting on the direct endpoint.

Try It

The API is live and free to use:

Direct endpoint: sec-edgar-insider-alerts-production.up.railway.app
RapidAPI (if you want managed auth + rate limiting): SEC Insider Trades on RapidAPI

No API key needed for the direct Railway endpoint. Just start making requests.