Amazon's 1-Click patent has 3,193 citing patents. Here's how to pull claims and citations for any patent number

I pulled 11 well-known patents from Google Patents on 2026-10-24: claims, legal status, citations in both directions and US court cases.

Patent	What it is	Cited by	Claims (independent)	Status on 2026-10-24	US court cases
US5960411A	Amazon 1-Click ordering	3,193	26 (4)	Expired, 2017-09-12	1
US7657849B2	Apple slide to unlock	2,378	23 (16)	Active until 2028-01-24	5
US7479949B2	Apple touch-screen heuristics	2,272	20 (3)	Active until 2027-09-05	9
US8697359B1	CRISPR-Cas9 gene editing	2,170	20 (3)	Active until 2033-10-15	4
US4405829A	RSA	1,994	41 (11)	Expired, 2000-09-20	6
US6285999B1	PageRank	1,663	29 (6)	Expired, 2018-01-09	0
US4558302A	LZW compression (the GIF one)	632	181 (2)	Expired, 2003-06-20	5
US4237224A	Cohen-Boyer recombinant DNA	508	14 (1)	Expired, 1997-12-02	0
US5443036A	Method of exercising a cat (laser pointer)	49	4 (1)	Expired, fees not paid	0
US5255452A	Anti-gravity illusion shoes	11	13 (3)	Expired, fees not paid	0
US6025810A	"Hyper-light-speed antenna"	4	30 (5)	Expired, 2017-10-02	0

A shopping-button patent from 1997 has been cited by more later patents than PageRank (also 1997) or RSA (1977). Below: how to get this table for your own list of numbers, two free ways, and three things in the data that will trip you up.

One patent by hand

Open patents.google.com/patent/US5960411A/en. The page shows the status ("Expired - Lifetime"), every claim in its own section, and a "Cited By (3193)" table further down. That's fine for five patents. For five hundred, you want code.

The free way for a list: Python

Google Patents has no official API, but each patent page is server-rendered HTML with itemprop attributes on the parts you care about. No browser needed:

import csv
import time

import httpx
from bs4 import BeautifulSoup

numbers = ["US5960411A", "US6285999B1", "US4405829A", "US5443036A"]

rows = []
for number in numbers:
    url = f"https://patents.google.com/patent/{number.upper()}/en"
    resp = httpx.get(url, timeout=30)
    if resp.status_code == 404:
        print("not found:", number)
        continue
    soup = BeautifulSoup(resp.text, "html.parser")
    rows.append({
        "number": number,
        "title": soup.find(itemprop="title").get_text(strip=True),
        "status": soup.find(itemprop="status").get_text(strip=True),
        "claims": len(soup.select("section[itemprop=claims] .claim[num]")),
        "cited_by": len(soup.select("tr[itemprop=forwardReferences]")),
    })
    time.sleep(1)

with open("patents.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=rows[0].keys())
    writer.writeheader()
    writer.writerows(rows)

What it wrote on 2026-10-24:

number,title,status,claims,cited_by
US5960411A,Method and system for placing a purchase order via a communications network,Expired - Lifetime,26,3193
US6285999B1,Method for node ranking in a linked database,Expired - Lifetime,29,1663
US4405829A,Cryptographic communications system and method,Expired - Lifetime,41,1994
US5443036A,Method of exercising a cat,Expired - Fee Related,4,49

Three details in that code matter:

• .upper() is there because us6285999b1 returns a 404. Strip spaces and commas too if your numbers come from a spreadsheet (US 6,285,999 B1).
• itemprop="status" only exists on US pages. European and Chinese pages put the status in the legal-events timeline instead, so that line needs a fallback outside the US.
• Stay on /patent/ pages. Google Patents' robots.txt disallows its search endpoint and allows individual patent pages. One request a second was fine in my testing.

The free way for thousands: BigQuery

Google also publishes patent data as a public BigQuery dataset, patents-public-data, with one row per publication worldwide, including claims and citations. For tens of thousands of patents, that beats fetching pages one by one.

The catches: you need a Google Cloud project and some SQL, and the claim text is large, so a query that selects it eats into the free 1 TB a month quickly. Dry-run every query first to see how many bytes it will scan.

For US patents only, the USPTO's bulk tables (formerly PatentsView) are now on the USPTO Open Data Portal, which needs a free USPTO.gov account to download.

What the data shows

A shopping button out-cites PageRank and RSA. 1-Click has 3,193 citing patents, PageRank 1,663 with the same 1997 priority year, and RSA 1,994 with a 20-year head start. I haven't looked at who the citing patents are, so I won't guess why. That would take the full cited-by lists, which is a follow-up in itself.

Claim count says little about scope. LZW has 181 claims, but only 2 are independent: claims 1 and 107. Every other claim narrows one of those two. Slide-to-unlock has 23 claims and 16 of them are independent. If you compare patents, count the independent claims.

Three of the 11 are still in force, all filed in 2005 or later: slide-to-unlock until 2028-01-24, the touch-screen heuristics patent until 2027-09-05 and CRISPR-Cas9 until 2033-10-15. The touch-screen patent also has the most US court cases in the set, 9.

The cat patent is shorter than most product pages. Four claims, one independent, and claim 1 starts "A method of inducing aerobic exercise in an unrestrained cat".

Three things that will trip you up

1. Expiry dates on lapsed patents. For the cat and the anti-gravity shoe patents, status is "Expired - Fee Related" and Google's expiry date (2013-11-02 and 2012-06-29) is the "Anticipated expiration" event: the 20-year date. They actually lapsed earlier, when maintenance fees weren't paid. Don't use the expiry date to say when a lapsed patent became free to use.

2. Dependent claims aren't always marked. On US pages, a dependent claim links to its parent in the HTML (a claim-ref tag). Machine-translated pages don't have those links, so you have to spot "according to claim 3" in the text. On EP3000000A1, translated from German, that gives two independent claims: 1 (a system) and 12 (a method).

3. Translated pages contain both languages. Each translated sentence keeps the original in a hidden span.google-src-text. Remove those before you read any text, or every claim comes out twice:

for original in soup.select("span.google-src-text"):
    original.decompose()

The short path

Disclosure: I built Google Patents Scraper, a hosted version of the above on Apify. You paste numbers in any format and get one record per patent: every claim flagged independent or dependent, legalStatus, expirationDate, citations both ways, litigationCount, CPC codes, and English translations of non-English patents. The input for this article was just the list:

{"patentNumbers": ["US5960411A", "US7657849B2", "US7479949B2", "US8697359B1", "US4405829A", "US6285999B1",
                   "US4558302A", "US4237224A", "US5443036A", "US5255452A", "US6025810A"]}

And part of one record:

{
  "publicationNumber": "US5960411A",
  "title": "Method and system for placing a purchase order via a communications network",
  "legalStatus": "Expired - Lifetime",
  "expirationDate": "2017-09-12",
  "grantDate": "1999-09-28",
  "assignee": "Amazon.com Inc",
  "claimsCount": 26,
  "independentClaimsCount": 4,
  "litigationCount": 1,
  "citedByCount": 3193,
  "claims": [
    {"number": 1, "independent": true, "text": "1. A method of placing an order for an item comprising: ..."},
    {"number": 2, "independent": false, "text": "2. The method of claim 1 wherein ..."}
  ]
}

It costs $0.003 per patent, so these 11 cost $0.033, and numbers that don't exist aren't charged. It looks patents up by number and doesn't search, so find the numbers first with Google Patents' own search page or BigQuery.

---

I wrote this with help from an AI assistant and checked every claim, number and code sample myself. The data was fetched on 2026-10-24.