Patent Filings API

Retrieve USPTO granted patents mapped to stock tickers. Track patent grants, technology classifications (CPC), claim counts, inventors, and filing-to-grant timing for any covered company.

Endpoint

GET /v2/patent-filings/{symbol}

Authentication

The API supports multiple authentication methods:

Method	Example
Bearer token (recommended)	`Authorization: Bearer YOUR_API_KEY`
X-API-Key header	`X-API-Key: YOUR_API_KEY`
Query parameter	`?apiKey=YOUR_API_KEY`
Legacy query parameter	`?token=YOUR_API_KEY`

Parameters

Path Parameters

Parameter	Type	Required	Description
`symbol`	string	Yes	Stock ticker symbol (e.g., `AAPL`, `NVDA`)

Query Parameters

Parameter	Type	Required	Description
`startDate`	string	No	Start date for grant date (YYYY-MM-DD)
`endDate`	string	No	End date for grant date (YYYY-MM-DD)
`limit`	integer	No	Maximum number of results to return (1-500)

Request

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

df = fb.patent_filings.ticker("AAPL",
                              date_from="2025-01-01",
                              date_to="2025-12-31",
                              as_dataframe=True)
print(df)

import requests

headers = {"Authorization": "Bearer YOUR_API_KEY"}

response = requests.get(
    "https://api.finbrain.tech/v2/patent-filings/AAPL",
    headers=headers,
    params={"limit": 10}
)
data = response.json()

for p in data["data"]["patents"]:
    print(f"{p['patentDate']}  {p['patentId']}  "
          f"[{p['primaryCpcSection']}]  {p['title']}")

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.finbrain.tech/v2/patent-filings/AAPL"

#include <iostream>
#include <string>
#include <curl/curl.h>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* userp) {
    userp->append((char*)contents, size * nmemb);
    return size * nmemb;
}

json get_patent_filings(const std::string& symbol, const std::string& api_key) {
    CURL* curl = curl_easy_init();
    std::string response;

    if (curl) {
        std::string url = "https://api.finbrain.tech/v2/patent-filings/" + symbol;

        struct curl_slist* headers = nullptr;
        std::string auth_header = "Authorization: Bearer " + api_key;
        headers = curl_slist_append(headers, auth_header.c_str());

        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
        curl_easy_perform(curl);
        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }

    return json::parse(response);
}

int main() {
    auto result = get_patent_filings("AAPL", "YOUR_API_KEY");

    for (auto& p : result["data"]["patents"]) {
        std::cout << p["patentDate"].get<std::string>() << "  "
                  << p["patentId"].get<std::string>() << "  ["
                  << p["primaryCpcSection"].get<std::string>() << "]  "
                  << p["title"].get<std::string>()
                  << std::endl;
    }

    return 0;
}

use reqwest::blocking::Client;
use serde::Deserialize;
use std::error::Error;

#[derive(Debug, Deserialize)]
struct Patent {
    #[serde(rename = "patentId")]
    patent_id: String,
    #[serde(rename = "patentDate")]
    patent_date: String,
    title: String,
    #[serde(rename = "type")]
    patent_type: String,
    kind: String,
    #[serde(rename = "numClaims")]
    num_claims: i64,
    #[serde(rename = "numCitedBy")]
    num_cited_by: i64,
    #[serde(rename = "assigneeOrganization")]
    assignee_organization: String,
    #[serde(rename = "assigneeType")]
    assignee_type: String,
    #[serde(rename = "applicationFilingDate")]
    application_filing_date: String,
    #[serde(rename = "filingToGrantDays")]
    filing_to_grant_days: i64,
    inventors: Vec<String>,
    #[serde(rename = "numInventors")]
    num_inventors: i64,
    #[serde(rename = "cpcSections")]
    cpc_sections: Vec<String>,
    #[serde(rename = "cpcSubsections")]
    cpc_subsections: Vec<String>,
    #[serde(rename = "primaryCpcSection")]
    primary_cpc_section: String,
}

#[derive(Debug, Deserialize)]
struct PatentData {
    symbol: String,
    name: String,
    patents: Vec<Patent>,
}

#[derive(Debug, Deserialize)]
struct PatentResponse {
    success: bool,
    data: PatentData,
}

fn get_patent_filings(symbol: &str, api_key: &str)
    -> Result<PatentResponse, Box<dyn Error>> {
    let url = format!(
        "https://api.finbrain.tech/v2/patent-filings/{}",
        symbol
    );

    let client = Client::new();
    let response: PatentResponse = client
        .get(&url)
        .bearer_auth(api_key)
        .send()?
        .json()?;

    Ok(response)
}

fn main() -> Result<(), Box<dyn Error>> {
    let result = get_patent_filings("AAPL", "YOUR_API_KEY")?;

    for p in &result.data.patents {
        println!("{}  {}  [{}]  {}",
            p.patent_date, p.patent_id, p.primary_cpc_section, p.title);
    }

    Ok(())
}

const response = await fetch(
  "https://api.finbrain.tech/v2/patent-filings/AAPL",
  { headers: { "Authorization": "Bearer YOUR_API_KEY" } }
);
const result = await response.json();

for (const p of result.data.patents) {
  console.log(`${p.patentDate}  ${p.patentId}  [${p.primaryCpcSection}]  ${p.title}`);
}

Response

Success Response (200 OK)

{
  "success": true,
  "data": {
    "symbol": "AAPL",
    "name": "Apple Inc.",
    "patents": [
      {
        "patentId": "12345678",
        "patentDate": "2025-03-11",
        "title": "Method and apparatus for low-power display synchronization",
        "type": "utility",
        "kind": "B2",
        "numClaims": 20,
        "numCitedBy": 0,
        "assigneeOrganization": "Apple Inc.",
        "assigneeType": "2",
        "applicationFilingDate": "2022-06-15",
        "filingToGrantDays": 999,
        "inventors": ["John Doe", "Jane Smith"],
        "numInventors": 2,
        "cpcSections": ["G", "H"],
        "cpcSubsections": ["G06", "H04"],
        "primaryCpcSection": "G"
      }
    ]
  },
  "meta": {
    "timestamp": "2026-06-16T12:00:00.000Z"
  }
}

Response Fields

Field	Type	Description
`success`	boolean	Whether the request was successful
`data.symbol`	string	Stock ticker symbol
`data.name`	string	Company name
`data.patents`	array	Array of granted patent objects
`meta.timestamp`	string	Response timestamp (ISO 8601)

Patent Object Fields

Field	Type	Description
`patentId`	string	USPTO patent number (globally unique)
`patentDate`	string	Grant date (YYYY-MM-DD)
`title`	string	Patent title
`type`	string	Patent type (utility, design, plant, reissue)
`kind`	string	USPTO kind code (e.g., `B2`, `S1`)
`numClaims`	number	Number of claims in the patent
`numCitedBy`	number	Forward-citation count
`assigneeOrganization`	string	Organization the patent is assigned to
`assigneeType`	string	Assignee type code (`2` = US company, `3` = foreign company)
`applicationFilingDate`	string	Original application filing date (YYYY-MM-DD)
`filingToGrantDays`	number	Days from filing to grant
`inventors`	array	Named inventors
`numInventors`	number	Number of inventors
`cpcSections`	array	CPC classification sections
`cpcSubsections`	array	CPC subsections
`primaryCpcSection`	string	Leading CPC section

Errors

Code	Error	Description
400	Bad Request	Invalid symbol or parameters
401	Unauthorized	Invalid or missing API key
403	Forbidden	Authenticated, but not authorized to access this resource
404	Not Found	Ticker not found
429	Too Many Requests	Rate limit exceeded — wait and retry
500	Internal Server Error	Server-side error

Patent Filings Dataset - Use cases and analysis examples
Stock Screener API - Screen patent filings across tickers
Government Contracts API - Federal contract awards
Insider Transactions API - Insider trading data