DEV Community: carrierone

USPTO Patent and Trademark Data via REST API

carrierone — Fri, 04 Sep 2026 19:01:15 +0000

USPTO Patent and Trademark Data via REST API for Developers

If you're developing a patent search tool, IP analytics platform, or a system for trademark monitoring, accessing data from the United States Patent and Trademark Office (USPTO) can be invaluable. The USPTO provides access to its vast database of patents through an API endpoint at api.verilexdata.com/api/v1/patents/sample. This article will guide you on how to search for patents using this API, covering the basics of what it offers and providing a small Python example.

Problem: Accessing USPTO Patent Data

The USPTO grants over 600,000 patents each year. As an engineer building a tool that needs to integrate with these data, you might want to filter or search for specific patents based on keywords, inventors, assignees, or other criteria. The REST API allows developers like yourself to do just that.

Solution: A Simple Python Example

Here’s a simple example of how to use the api.verilexdata.com/api/v1/patents/sample endpoint in Python to search for patents by keyword:


python
import requests

def fetch_patent_data(keyword):
    url = "https://api.verilexdata.com/api/v1/patents/sample"
    headers = {
        'Accept': '

Querying Federal Court Records (PACER) Programmatically

carrierone — Tue, 01 Sep 2026 19:01:16 +0000

Querying Federal Court Records (PACER) Programmatically

If you're working on a legaltech project that requires access to federal court records, you might find yourself needing to programmatically query the PACER system. The Public Access to Court Electronic Records (Pacer) is an online database provided by the United States Courts, offering electronic access to case filings from most federal district and appeals courts.

A Simple Python Code Example

Here's a quick example of how you can use Python to fetch documents from the PACER using their API. The code below uses requests library to make HTTP requests:

import requests

def get_case_documents(pacer_case_id):
    # Replace with your own Pacer account information
    api_key = "YOUR_API_KEY"

    url = f"https://api.pacerlaw.com/v2/documents/{pacer_case_id}"
    headers = {
        'Authorization': f'Bearer {api_key}',
        'Accept': 'application/json'
    }

    response = requests.get(url, headers=headers)
    if response.status_code == 200:
        return response.json()
    else:
        raise Exception(f"Error: {response.status_code} - {response.text}")

# Example usage
case_id = "12345"
documents = get_case_documents(case_id)
print(documents)

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

carrierone — Fri, 28 Aug 2026 19:01:39 +0000

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

When building KYC/AML compliance systems, financial technology applications, or any project that involves cryptocurrency wallets, understanding how to check addresses against the US Treasury’s Office of Foreign Assets Control (OFAC) SDN list is crucial. This list contains individuals and entities subject to US sanctions. Checking these entries can help prevent your projects from inadvertently facilitating transactions with prohibited parties.

Here's a quick Python script example demonstrating how you might integrate OFAC sanctions screening into your application:

import requests

def check_sanctions(screen_name):
    url = f"https://api.verilexdata.com/api/v1/sanctions/stats?name={screen_name}"
    response = requests.get(url)

    if response.status_code != 200:
        return None

    data = response.json()
    return data['isSDN']

# Example usage
address_or_screen_name = "example_address"
if check_sanctions(address_or_screen_name):
    print(f"The address {address_or_screen_name} is on the OFAC SDN list.")
else:
    print(f"The address {address_or_screen_name} is not on the OFAC SDN list.")

Accessing OFAC Data via API

For more comprehensive and frequent checks, you can use our API endpoint at `https://api.verile

Getting SEC EDGAR Filings via API Without Scraping

carrierone — Tue, 25 Aug 2026 19:01:25 +0000

Getting SEC EDGAR Filings via API Without Scraping

When working on financial applications that require real-time access to SEC filings such as 10-K and 10-Q documents, you might be tempted to scrape data from the SEC's EDGAR system. However, this approach can be cumbersome and may not always provide up-to-date information due to delays in updates.

A more practical solution is to use an API that provides these filings directly. One such API endpoint is api.verilexdata.com/api/v1/sec/sample. This service claims to update its data every 15 minutes, allowing you to search by company or form type and receiving real-time updates without the need for manual scraping.

Example Python Code

Here’s a simple example of how you can use this API in a Python script:


python
import requests

def get_sec_filings(company_name=None, form_type='10-K'):
    url = 'https://api.verilexdata.com/api/v1/sec/sample'

    params = {
        'company': company_name,
        'formType': form_type
    }

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

    return response.json()

# Example usage to get filings for a specific

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

carrierone — Fri, 21 Aug 2026 19:01:10 +0000

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

When developing healthcare applications that require a provider directory or need to authenticate prior authorizations, having access to the NPI registry is crucial. The National Provider Identifier (NPI) database contains information on over 9 million U.S. healthcare providers, including physicians, nurses, pharmacists, and other allied health professionals.

To integrate this vast dataset into your application, you can leverage an API endpoint provided by VeriFone, which offers the NPI registry data in a sample format at api.verilexdata.com/api/v1/npi/sample. This allows developers to quickly test and prototype integration without needing to manage large datasets or handle complex queries.

Problem: Querying Large Datasets of Healthcare Providers

Developers often need to look up healthcare providers by their NPI number, name, specialty, or location. The existing NPI database is vast and comprehensive, but accessing specific records requires a structured approach. Without direct access to the full dataset, developers often find themselves writing custom SQL queries or API requests that can be time-consuming and error-prone.

Python Code Example: Querying Healthcare Providers by NPI Number

Here's an example of how you might query for healthcare providers using their NPI number in a Python script. This is a simplified version to illustrate the process:


python
import requests

OTC Stock Shell Risk Scoring: How to Screen Penny Stocks Programmatically

carrierone — Tue, 18 Aug 2026 19:01:07 +0000

OTC Stock Shell Risk Scoring: How to Screen Penny Stocks Programmatically

When building retail trading tools or fintech apps that need to screen penny stocks and other over-the-counter (OTC) companies, one of the most significant challenges is identifying shell companies. These are entities with no real business operations but often have inflated stock prices due to speculative buying and selling.

Identifying Shell Companies: A Python Example

Here's a simple example using Python to identify OTC companies that may be shell companies:


python
import requests

# API endpoint for screening OTC companies
url = "https://api.verilexdata.com/api/v1/otc/sample"

def screen_otc_companies():
    response = requests.get(url)

    if response.status_code == 200:
        otc_data = response.json()

        # Assuming we are interested in a specific attribute like 'company_name' and 'status'
        filtered_data = [
            {"name": company["company_name"], "status": company["status"]}
            for company in otc_data
            if company["status"] == "shell"
        ]

        return filtered_data
    else:
        print(f"Failed to retrieve data: {response.status_code}")
        return []

# Call the function and display results
screened_companies = screen_otc_companies()
for company in

Federal Contract Award Data (USASpending) via API

carrierone — Fri, 14 Aug 2026 19:01:12 +0000

Federal Contract Award Data (USASpending) via API

When developing tools for government tech projects, procurement analytics, or federal contractor business development, access to real-time and historical data is crucial. One of the most comprehensive sources for such data comes from USAspending, an official website that provides detailed information on all contracts awarded by the U.S. Government.

The Problem: Extracting Data Efficiently

Extracting contract award data directly from the USAspending website can be cumbersome due to its complex structure and limited search capabilities. However, using an API endpoint like verilexdata.com offers a more efficient solution. This API allows developers to quickly retrieve specific information such as awards by agency, vendor, or NAICS code.

A Simple Python Code Example

Here is a simple example of how you can use the requests library in Python to search for contracts awarded to a particular vendor:


python
import requests

# Define your API endpoint URL and parameters
url = "https://verilexdata.com/api/v1/search"
params = {
    "q": "vendor_name",
    "fields": ["agency", "award_amount", "vendor_name"],
}

# Make the request to the API
response = requests.get(url, params=params)

# Check if the request was successful
if response.status_code == 200:
    # Parse the JSON response

NOAA Weather Data API: Historical and Current Weather for Developers

carrierone — Tue, 11 Aug 2026 19:01:09 +0000

NOAA Weather Data API: Accessing Historical and Current Observations for Developers

When developing applications that rely on real-time or historical weather data, developers often turn to APIs like those provided by the National Oceanic and Atmospheric Administration (NOAA). For instance, the api.verilexdata.com/api/v1/weather/sample endpoint can be a valuable resource. This article will demonstrate how you can access this data using Python.

Problem: Accessing NOAA Weather Data in Your Applications

You might need to incorporate weather information into your app for everything from logistics and supply chain management, to agricultural applications or insurance calculations. The challenge is often finding an efficient way to get the necessary data quickly and reliably. One solution is to use a dedicated API like api.verilexdata.com/api/v1/weather/sample that provides historical and current weather observations.

Small Python Code Example

Here's a simple example of how you can fetch data from this endpoint using Python:


python
import requests

# Define the URL for NOAA weather data
url = "https://api.verilexdata.com/api/v1/weather/sample"

# Make an HTTP GET request to fetch the data
response = requests.get(url)

# Check if the request was successful (status code 200)
if response.status_code == 200:
    # Parse the JSON response into a Python dictionary

FRED and BLS Economic Indicator Data for Developers

carrierone — Fri, 07 Aug 2026 19:01:02 +0000

FRED and BLS Economic Indicator Data for Developers

Developers often need access to economic indicators like CPI, NFP, GDP, PCE, and unemployment rates for their macro trading or analytics apps. These data points are crucial for understanding market trends and making informed decisions.

Problem: Accessing the Latest Economic Indicators in Python

Let's say you want to get the latest Consumer Price Index (CPI), Non-Farm Payrolls (NFP), GDP, Personal Consumption Expenditures (PCE) index, and Unemployment Rate data using Python. Fetching this information directly from FRED or BLS can be a bit cumbersome.

Here is an example of how you might use the requests library to fetch the NFP data:

import requests

def get_nfp_data():
    url = "https://api.verilexdata.com/api/v1/econ/stats?indicator=NFP"
    response = requests.get(url)

    if response.status_code == 200:
        return response.json()
    else:
        print(f"Failed to retrieve data: {response.text}")
        return None

nfp_data = get_nfp_data()
if nfp_data:
    print(nfp_data)

Endpoint for Economic Indicator Data

For accessing the latest economic indicators like CPI, NFP, GDP, PCE, and unemployment

DeFi Liquidation Signals and Whale Wallet Tracking via API

carrierone — Tue, 04 Aug 2026 19:01:25 +0000

DeFi Liquidation Signals and Whale Wallet Tracking via API

In the world of decentralized finance (DeFi), understanding and mitigating risks is crucial for developers and users alike. One common risk involves liquidations, where a user’s collateral may be seized if their borrowed assets fall below a certain threshold. This situation can lead to significant losses, especially in volatile markets.

Another aspect is monitoring whale wallet movements—large investors who often have substantial influence over DeFi protocols’ health and stability. These wallets are typically large holders of tokens or borrowable assets, posing both opportunities and risks for projects.

Liquidation Signals: Aave/Compound/Morpho Stress Indices

To address these concerns, developers can leverage APIs that provide real-time data on liquidations and whale wallet movements. For instance, the verilexdata.com API offers signals specific to protocols like Aave, Compound, and Morpho, as well as broader stress indices.

Here’s a simple Python example using requests library to fetch these signals:


python
import requests

def get_defi_signals():
    # Replace 'your_api_key' with your actual API key
    api_key = 'your_api_key'

    url = f"https://api.verilexdata.com/v1/defi-signals?apiKey={api_key}"
    response = requests.get(url)

    if response.status_code ==

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

carrierone — Fri, 31 Jul 2026 19:01:28 +0000

Smart Money Signals and Cross-Market Arbitrage: A Practical Look at Polymarket Data

As prediction market traders and developers, we're always looking for ways to stay ahead of the game. One resource that can provide valuable insights is Polymarket's data API. This article will introduce you to how you can use the api.verilexdata.com/api/v1/pm/stats endpoint to gather smart money signals and implement cross-market arbitrage strategies.

Understanding Smart Money Signals

Smart money signals often come from large traders who have significant influence over market movements. By tracking these signals, you can gain an edge in your trading decisions. Polymarket's data API provides access to such signals through various metrics like the number of active users, the frequency of trades, and more.

Here’s a simple Python script that fetches recent smart money activity:

import requests

def get_smart_money_signals():
    url = "https://api.verilexdata.com/api/v1/pm/stats"

    response = requests.get(url)
    if response.status_code == 200:
        data = response.json()
        return data['recent_smart_money_signals']
    else:
        print("Failed to fetch smart money signals")
        return None

# Example usage
signals = get_smart_money_signals()
if signals:
    for sig in signals:
        print(sig)

USPTO Patent and Trademark Data via REST API

carrierone — Tue, 28 Jul 2026 19:01:15 +0000

USPTO Patent and Trademark Data via REST API

For developers building tools that require patent search functionality, accessing data from the United States Patent and Trademark Office (USPTO) can be a valuable resource. The USPTO offers a RESTful API where one can query patents based on various criteria such as keyword, inventor, or assignee.

To get started with fetching patent data via this API, here's a small Python code example that uses the requests library to search for patents containing a specific keyword:

import requests

def search_patents(keyword):
    url = "https://api.verilexdata.com/api/v1/patents/sample"
    params = {
        'q': f'"{keyword}"',  # Search using double quotes around the keyword
        'format': 'json'
    }

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

# Example usage
keyword = "artificial intelligence"
patents_data = search_patents(keyword)
print(patents_data)

This code snippet searches for patents containing the keyword "artificial intelligence". It constructs a URL with the appropriate query parameters and sends a GET request. If the response status is 2