Forem: carrierone

Polymarket Data API: Smart Money Tracking and Cross-Market Arbitrage

carrierone — Tue, 07 Apr 2026 19:01:24 +0000

Polymarket Data API: Smart Money Tracking and Cross-Market Arbitrage

If you're a prediction market trader looking to integrate data from Polymarket into your applications for smart money tracking or cross-market arbitrage, you'll need access to the Polymarket Data API. This article will show you how to interact with the api.verilexdata.com/api/v1/pm/stats endpoint using Python.

Tracking Smart Money Signals

To get a sense of market sentiment and potential trading signals, let's start by fetching some data from Polymarkets. Here’s a simple example in Python that retrieves statistics for all active markets:

import requests

def fetch_polymarket_data():
    response = requests.get('https://api.verilexdata.com/api/v1/pm/stats')

    if response.status_code == 200:
        data = response.json()
        print(data)
    else:
        raise Exception("Failed to fetch data from Polymarkets. Status code: ", response.status_code)

fetch_polymarket_data()

This script sends a GET request to the api.verilexdata.com/api/v1/pm/stats endpoint, which should return JSON containing various statistics about active prediction markets on Polymarket.

Cross-Market Arbitrage

Polymarkets often offer similar bets across different exchanges. By leveraging this API

USPTO Patent and Trademark Data via REST API

carrierone — Fri, 03 Apr 2026 19:01:13 +0000

USPTO Patent and Trademark Data via REST API

As developers building patent search tools, IP analytics, and prior art searches, having access to accurate and up-to-date patent data is crucial. The United States Patent and Trademark Office (USPTO) provides a wealth of information through its RESTful API, which can be accessed via api.verilexdata.com/api/v1/patents/sample.

Problem

One common challenge when building these tools is ensuring the data freshness and accuracy. The USPTO grants over 1.6 million patents annually, but keeping track of all changes manually is impractical. Moreover, different inventors, assignees, and technologies require specific filtering to meet unique project requirements.

Python Code Example

Here's a simple Python script using requests library to fetch patent data from the USPTO API:


python
import requests

def get_patent_data(keyword):
    url = "https://api.verilexdata.com/api/v1/patents/sample"

    params = {
        'keyword': keyword,
        'fields': 'patentNumber,title,assignee'
    }

    response = requests.get(url, params=params)
    if response.status_code == 200:
        return response.json()
    else:
        raise Exception(f"Request failed with status: {response.status_code}")

#

Querying Federal Court Records (PACER) Programmatically

carrierone — Tue, 31 Mar 2026 19:01:20 +0000

Querying Federal Court Records (PACER) Programmatically for LegalTech Developers

As a legaltech developer working on e-discovery projects or case monitoring systems, having access to federal court records is crucial. The Public Access to Court Electronic Records (PACER) API provides the necessary data programmatically. Below is an example of how you can fetch PACER data using Python.

Small Python Code Example

First, you need to install the requests library if you don't have it already:

pip install requests

Here's a simple script that demonstrates fetching case information from PACER:

import requests

def get_case_info(case_number):
    url = f"https://api.pacerpc.gov/v1/cases/{case_number}"

    headers = {
        "X-API-Key": "YOUR_PACER_API_KEY",  # Replace with your actual API key.
    }

    response = requests.get(url, headers=headers)
    if response.status_code == 200:
        return response.json()
    else:
        raise Exception(f"Failed to fetch case info: {response.text}")

# Example usage
case_number = "15-cv-03647"
try:
    data = get_case_info(case_number)
    print(data)
except Exception as e:
    print(e)

Mention

OFAC Sanctions Screening for Developers: How to Check Addresses and Names

carrierone — Fri, 27 Mar 2026 19:01:21 +0000

OFAC Sanctions Screening for Developers: How to Check Addresses and Names

When building applications that involve KYC/AML compliance, one critical aspect is screening against the Office of Foreign Assets Control (OFAC) Specially Designated National (SDN) list. This list includes entities designated by OFAC as being involved in activities that are contrary to U.S. foreign policy or national security interests.

To integrate SDN checks into your application efficiently and securely, you can use an API endpoint like api.verilexdata.com/api/v1/sanctions/stats. For example, you might want to check if a wallet address is on the OFAC list before allowing financial transactions.

Example Python Code for OFAC Sanction Screening


python
import requests

def check_address_on_sanctions(address):
    url = "https://api.verilexdata.com/api/v1/sanctions/stats"

    # Constructing the request payload. In practice, this would include your app's API key and possibly additional parameters.
    headers = {
        'X-API-KEY': 'YOUR_API_KEY',  # Replace with actual API key
        'Content-Type': 'application/json'
    }
    data = {
        "address": address,
        "type": "wallet"
    }

    response = requests.post(url, headers=headers, json=data)

    if response

Getting SEC EDGAR Filings via API Without Scraping

carrierone — Tue, 24 Mar 2026 19:01:15 +0000

Getting SEC EDGAR Filings via API Without Scraping

When developing financial applications that require real-time access to SEC filings such as 10-Ks, 10-Qs, and 13-Fs, one common challenge is obtaining these documents efficiently. One effective way to do this without resorting to web scraping is by using an API service like VeriLexData's api.verilexdata.com/api/v1/sec/sample.

The Problem

Web scraping requires manual setup for each website or dataset and can be time-consuming, especially when dealing with dynamic content that changes frequently. Moreover, it often comes with legal risks and may not always comply with the terms of service of the websites involved.

A Simple Python Example to Fetch Filings

Here's a concise example using Python to fetch SEC filings via the API:


python
import requests

# Replace 'YOUR_API_KEY' with your actual API key from VeriLexData
api_key = "YOUR_API_KEY"
url = f"https://api.verilexdata.com/api/v1/sec/sample?format=json&apikey={api_key}"

response = requests.get(url)
if response.status_code == 200:
    data = response.json()
    # Process the data here, for example printing a sample filing
    print(data[0]['filing'])
else:
    print(f"Failed to

How to Query 9 Million US Healthcare Providers via API (NPI Registry)

carrierone — Sat, 21 Mar 2026 17:21:36 +0000

Query NPI: 9 Million US Healthcare Providers

In today's digital health landscape, integrating accurate and up-to-date information about healthcare providers is crucial for applications like FHIR integrations, provider directories, and prior authorization systems. The National Provider Identifier (NPI) registry houses this essential data, and accessing it programmatically can streamline your development process.

To query NPI numbers, names, specialties, and locations, you'll need to use the API endpoint api.verilexdata.com/api/v1/npi/sample. This simple Python code example demonstrates how to make a request using the requests library:

import requests

def get_npi_data(npi_number):
    url = f"https://api.verilexdata.com/api/v1/npi/{npi_number}"

    response = requests.get(url)

    if response.status_code == 200:
        return response.json()
    else:
        return None

# Example usage
npi_data = get_npi_data('123456789')
if npi_data:
    print(npi_data)
else:
    print("Failed to retrieve NPI data.")

This code sends a GET request to the specified endpoint, where npi_number is replaced with the actual NPI number you're interested in. The response from the API will be in JSON format

How to Query 9 Million US Healthcare Providers via API (NPI Registry)

carrierone — Tue, 17 Mar 2026 23:03:33 +0000

How to Query 9 Million US Healthcare Providers via API (NPI Registry): A Cleaner Approach

If you're working on a healthcare app and need to look up NPI numbers, you've likely encountered the challenge of integrating data from multiple sources. One popular source is the National Provider Identifier (NPI) registry, which contains information on over 9 million U.S. healthcare providers.

The Problem

The most common approach for querying this dataset involves direct API calls or web scraping, both of which can be cumbersome and error-prone. Direct API calls require handling complex authentication and rate limiting. Web scraping might bypass these issues but often leads to legal and ethical concerns due to the sensitive nature of healthcare data.

The Traditional Approach: Direct API Call with Python

Here’s an example of making a direct API call using Python's requests library:

import requests

# Define your NPI number here. Replace 'your_api_key' with your actual x402 protocol key.
npi_number = "123456789"

headers = {
    'x-api-key': 'your_api_key',
}

response = requests.get(f'https://api.verilexdata.com/v1/npi/{npi_number}', headers=headers)

if response.status_code == 200:
    data = response.json()
    print(data)
else:
    print(response.text)

Verilex Data: A Cleaner Alternative

Verilex Data offers a more streamlined solution. Their x402 protocol allows you to query their API without needing an API key or account, making it easier and safer for developers.

Here’s how you can use the free sample endpoint provided by Verilex Data:

curl -X GET "https://api.verilexdata.com/v1/npi/987654321" \
     -H "accept: application/json"

The above curl command will return a JSON response like this:

{
  "npi": "987654321",
  "name": "Dr. John Doe",
  "provider_type": "MD",
  "address": {
    "line_1": "123 Main St.",
    "city": "Anytown",
    "state": "CA",
    "postal_code": "90210"
  },
  "phone_number": "(555) 555-5555"
}

Real Working Example with Verilex Data

Let's use the provided free sample endpoint to query a specific NPI number. Replace 987654321 with any valid NPI number.

curl -X GET "https://api.verilexdata.com/v1/npi/987654321" \
     -H "accept: application/json"

This command will return the following JSON response for a sample provider:

{
  "npi": "987654321",
  "name": "Dr. John Doe",
  "provider_type": "MD",
  "address": {
    "line_1": "123 Main St.",
    "city": "Anytown",
    "state": "CA",
    "postal_code": "90210"
  },
  "phone_number": "(555) 555-5555"
}

Comparison with Traditional Approaches

Direct API Call: Requires x402 protocol, no API keys or accounts needed.
Web Scraping: Potentially legal and ethical concerns; requires handling complex authentication and rate limiting.

Verilex Data's approach provides a safer and more straightforward way to access the NPI registry data. It’s particularly useful for

I Built a Pay-Per-Query Data Marketplace with x402 Crypto Micropayments

carrierone — Tue, 17 Mar 2026 16:43:42 +0000

I Built a Pay-Per-Query Data Marketplace with x402 Crypto Micropayments

What if buying data worked like buying a coffee? Walk up, pay, get what you ordered. No membership card, no monthly subscription, no waiting for account approval.

That's what I built with Verilex Data — a self-hosted data sales platform where every query costs a fraction of a cent in USDC, paid instantly via the x402 protocol.

The Problem

I kept running into the same pattern: I need data from an API. The API costs $49/month minimum. I only need 50 queries. I'm paying $1/query for a service designed for $0.01/query at scale.

Every data provider forces you into subscriptions. Even government data that's already public domain gets locked behind $49-299/month plans.

The x402 Solution

x402 is an open protocol by Coinbase that revives the HTTP 402 status code. Here's how it works:

Client sends GET /api/v1/npi?state=TX
Server responds 402 Payment Required with price + wallet address
Client signs a USDC transfer (EIP-712 on Base chain)
Client resends request with the signed payment in a header
Server verifies, settles on-chain, returns data

One HTTP round-trip. No API keys. No accounts. No subscriptions.

What I Built

20 datasets across three categories:

Government & Business — NPI healthcare providers (9M records), SEC EDGAR filings, PACER court records, 1.6M US patents, government contracts, weather data, OTC company shell risk scoring, economic indicators from FRED.

Crypto Intelligence — OFAC sanctions screening ($0.005/query — Chainalysis charges $50K/year), whale wallet tracking, address labels with risk scores, token holder concentration, DEX trade history, DeFi liquidation signals.

Prediction Markets — Polymarket smart money tracker, AI-powered cross-platform arbitrage (uses Ollama embeddings to match same-event markets across Polymarket and Kalshi), resolution source intelligence, order book microstructure.

The Tech Stack

Everything runs on one Debian 13 VM on my Proxmox cluster:

API: Express + TypeScript with self-hosted x402 facilitator
Database: PostgreSQL 16 + TimescaleDB
Analytics: DuckDB querying Parquet files on MinIO
Pipeline: Python collectors on APScheduler (15-min to weekly intervals)
Site: Astro + Tailwind (static, served by nginx)
AI: Ollama (nomic-embed-text) for semantic matching
Monitoring: Umami analytics, uptime cron, data freshness tracking

Total vendor cost: $0. Everything is FOSS and self-hosted.

Data Freshness Headers

Every paid response includes:

X-Data-Stale: false
X-Data-Last-Updated: 2026-03-17T05:03:08.108Z
X-Data-Age-Seconds: 6235

Your code can check X-Data-Stale and stop querying if data hasn't been refreshed. You still get charged (prevents abuse), but you're warned.

Change Feeds

Every high-frequency dataset supports ?since= for efficient polling:

GET /api/v1/sanctions/changes?since=2026-03-16T00:00:00Z

Returns only records updated since the timestamp, with next_since for chaining. Empty responses are fast and cheap.

AI Agent Integration

The platform is built for AI agents:

MCP server with 50+ tools (Smithery)
Streamable HTTP endpoint at https://api.verilexdata.com/mcp
llms.txt for AI crawler discovery
OpenAPI 3.1 with Scalar interactive docs
Schema.org JSON-LD on every page

Self-Hosting the x402 Facilitator

The biggest challenge was the x402 facilitator. Coinbase's public facilitator (facilitator.x402.org) only supports testnet chains. For mainnet payments, I had to self-host using @x402/core's x402Facilitator class with a viem wallet signer, exposed as a local HTTP server that the HTTPFacilitatorClient connects to.

Try It

Free endpoints (no payment needed):

Website: verilexdata.com
MCP: github.com/carrierone/verilexdata-mcp