PatentsView-compatible

Assignees, inventors and locations

One record per assignee, inventor, attorney and location, with their activity over time. IDs come from our own matching, so they don't equal PatentsView's.

Send q, f, s and o as one JSON body with POST, or as JSON-encoded query parameters with GET.

56 of 57 PatentsView fields are served; inventor_gender_code is not, because PatentsView infers gender from first names. Entity IDs such as inventor_id are our own. All differences

/api/v1/assignee/
/api/v1/inventor/
/api/v1/patent/attorney/
/api/v1/location/

Response200Recorded 11 Oct 2026

{
  "error": false,
  "count": 3,
  "total_hits": 39,
  "assignees": [
    {
      "assignee_id": "ed0787150cf417a4cf9d55b19a337323",
      "assignee_organization": "Tesla, Inc.",
      "assignee_num_patents": 607
    },
    {
      "assignee_id": "d5969b7ef51e6471da22473bb5230778",
      "assignee_organization": "Tesla Motors, Inc.",
      "assignee_num_patents": 286
    },
    {
      "assignee_id": "af32f6b80c1ff69a645a101807b00d79",
      "assignee_organization": "Tesla Nanocoatings, Inc.",
      "assignee_num_patents": 21
    }
  ]
}

Request body

qobjectRequired

The query. A field and value matches exactly; combine clauses with _and, _or and _not. Dates use YYYY-MM-DD.

farray of stringsDefault: the endpoint's default fields

Fields to return. Name a group such as assignees to get all of its fields, or one field such as assignees.assignee_organization.

sarray of objects

Sort order, for example [{"patent_date": "desc"}]. Only sortable fields are allowed; end with a unique field to keep paging stable.

oobject

sizeRows per page. Default 100, up to 1,000. 0 returns only the count.afterCursor: the last row's sort values, in sort order.offsetSkip rows. Don't combine with after.

Operators and cursor paging work as on Patents.

curl https://api.patentgrep.com/api/v1/assignee/ \
  -H "X-Api-Key: $PATENTGREP_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "q": {"_text_phrase": {"assignee_organization": "Tesla"}},
    "f": [
      "assignee_id",
      "assignee_organization",
      "assignee_num_patents"
    ],
    "s": [{"assignee_num_patents": "desc"}],
    "o": {"size": 3}
  }'

import os, requests

resp = requests.post(
    "https://api.patentgrep.com/api/v1/assignee/",
    headers={"X-Api-Key": os.environ["PATENTGREP_KEY"]},
    json={
          "q": {"_text_phrase": {"assignee_organization": "Tesla"}},
          "f": [
            "assignee_id",
            "assignee_organization",
            "assignee_num_patents"
          ],
          "s": [{"assignee_num_patents": "desc"}],
          "o": {"size": 3}
        },
)
resp.raise_for_status()
data = resp.json()
print(data)

const res = await fetch("https://api.patentgrep.com/api/v1/assignee/", {
  headers: {
    "X-Api-Key": process.env.PATENTGREP_KEY,
    "Content-Type": "application/json",
  },
  method: "POST",
  body: JSON.stringify({
    "q": {"_text_phrase": {"assignee_organization": "Tesla"}},
    "f": [
      "assignee_id",
      "assignee_organization",
      "assignee_num_patents"
    ],
    "s": [{"assignee_num_patents": "desc"}],
    "o": {"size": 3}
  }),
});
if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);
const data = await res.json();
console.log(data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{
	  "q": {"_text_phrase": {"assignee_organization": "Tesla"}},
	  "f": [
	    "assignee_id",
	    "assignee_organization",
	    "assignee_num_patents"
	  ],
	  "s": [{"assignee_num_patents": "desc"}],
	  "o": {"size": 3}
	}`)

	req, err := http.NewRequest(http.MethodPost, "https://api.patentgrep.com/api/v1/assignee/", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-Api-Key", os.Getenv("PATENTGREP_KEY"))
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	data, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}
	if res.StatusCode != http.StatusOK {
		panic(fmt.Sprintf("%s: %s", res.Status, data))
	}
	fmt.Println(string(data))
}

require "json"
require "net/http"

uri = URI("https://api.patentgrep.com/api/v1/assignee/")

req = Net::HTTP::Post.new(uri)
req["X-Api-Key"] = ENV.fetch("PATENTGREP_KEY")
req["Content-Type"] = "application/json"
req.body = <<~'JSON'
  {
    "q": {"_text_phrase": {"assignee_organization": "Tesla"}},
    "f": [
      "assignee_id",
      "assignee_organization",
      "assignee_num_patents"
    ],
    "s": [{"assignee_num_patents": "desc"}],
    "o": {"size": 3}
  }
JSON

res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(req) }
raise "#{res.code}: #{res.body}" unless res.is_a?(Net::HTTPSuccess)
data = JSON.parse(res.body)
p data

/api/v1/assignee/

POSThttps://api.patentgrep.com/api/v1/assignee/

Rows come back in assignees. Without f you get assignee_id, assignee_organization, assignee_individual_name_first. One record by id: GET /api/v1/assignee/{assignee_id}/.

18 fields

Field	Type	Sort	Description
`assignee_id`	string	Yes	Unique identifier for the assignee.
`assignee_organization`	string	No	Name of the organization, if the assignee is an organization.
`assignee_individual_name_first`	string	No	First name of the assignee, if an individual.
`assignee_individual_name_last`	string	No	Last name of the assignee, if an individual.
`assignee_type`	string	No	Type of assignee (e.g., individual, corporate).
`assignee_lastknown_city`	string	No	City where the assignee was last known to reside or be located.
`assignee_lastknown_state`	string	No	State where the assignee was last known to reside or be located.
`assignee_lastknown_country`	string	No	Country where the assignee was last known to reside or be located.
`assignee_lastknown_latitude`	number	Yes	Latitude of the last known location of the assignee.
`assignee_lastknown_longitude`	number	Yes	Longitude of the last known location of the assignee.
`assignee_lastknown_location`	string	No	Location identifier for the last known location of the assignee.
`assignee_first_seen_date`	date	Yes	Date when the assignee was first recorded.
`assignee_last_seen_date`	date	Yes	Date when the assignee was last recorded.
`assignee_years_active`	integer	Yes	Number of years the assignee has been active.
`assignee_num_patents`	integer	Yes	Number of patents associated with the assignee.
`assignee_num_inventors`	integer	Yes	Number of inventors associated with the assignee.
`assignee_years.year`	integer	No	The year in which the patents were recorded.
`assignee_years.num_patents`	integer	No	The number of patents recorded in the specified year.

curl https://api.patentgrep.com/api/v1/assignee/ \
  -H "X-Api-Key: $PATENTGREP_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "q": {"assignee_id": "example-id"},
    "f": [
      "assignee_id",
      "assignee_organization",
      "assignee_individual_name_first"
    ],
    "s": [{"assignee_id": "asc"}],
    "o": {"size": 25}
  }'

import os, requests

resp = requests.post(
    "https://api.patentgrep.com/api/v1/assignee/",
    headers={"X-Api-Key": os.environ["PATENTGREP_KEY"]},
    json={
          "q": {"assignee_id": "example-id"},
          "f": [
            "assignee_id",
            "assignee_organization",
            "assignee_individual_name_first"
          ],
          "s": [{"assignee_id": "asc"}],
          "o": {"size": 25}
        },
)
resp.raise_for_status()
data = resp.json()
print(data)

const res = await fetch("https://api.patentgrep.com/api/v1/assignee/", {
  headers: {
    "X-Api-Key": process.env.PATENTGREP_KEY,
    "Content-Type": "application/json",
  },
  method: "POST",
  body: JSON.stringify({
    "q": {"assignee_id": "example-id"},
    "f": [
      "assignee_id",
      "assignee_organization",
      "assignee_individual_name_first"
    ],
    "s": [{"assignee_id": "asc"}],
    "o": {"size": 25}
  }),
});
if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);
const data = await res.json();
console.log(data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{
	  "q": {"assignee_id": "example-id"},
	  "f": [
	    "assignee_id",
	    "assignee_organization",
	    "assignee_individual_name_first"
	  ],
	  "s": [{"assignee_id": "asc"}],
	  "o": {"size": 25}
	}`)

	req, err := http.NewRequest(http.MethodPost, "https://api.patentgrep.com/api/v1/assignee/", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-Api-Key", os.Getenv("PATENTGREP_KEY"))
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	data, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}
	if res.StatusCode != http.StatusOK {
		panic(fmt.Sprintf("%s: %s", res.Status, data))
	}
	fmt.Println(string(data))
}

require "json"
require "net/http"

uri = URI("https://api.patentgrep.com/api/v1/assignee/")

req = Net::HTTP::Post.new(uri)
req["X-Api-Key"] = ENV.fetch("PATENTGREP_KEY")
req["Content-Type"] = "application/json"
req.body = <<~'JSON'
  {
    "q": {"assignee_id": "example-id"},
    "f": [
      "assignee_id",
      "assignee_organization",
      "assignee_individual_name_first"
    ],
    "s": [{"assignee_id": "asc"}],
    "o": {"size": 25}
  }
JSON

res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(req) }
raise "#{res.code}: #{res.body}" unless res.is_a?(Net::HTTPSuccess)
data = JSON.parse(res.body)
p data

/api/v1/inventor/

POSThttps://api.patentgrep.com/api/v1/inventor/

Rows come back in inventors. Without f you get inventor_id, inventor_name_first, inventor_name_last. One record by id: GET /api/v1/inventor/{inventor_id}/.

17 fields

Field	Type	Sort	Description
`inventor_id`	string	Yes	Unique identifier for the inventor.
`inventor_name_first`	string	No	First name of the inventor.
`inventor_name_last`	string	No	Last name of the inventor.
`inventor_lastknown_city`	string	No	City where the inventor was last known to reside or be located.
`inventor_lastknown_state`	string	No	State where the inventor was last known to reside or be located.
`inventor_lastknown_country`	string	No	Country where the inventor was last known to reside or be located.
`inventor_lastknown_latitude`	number	Yes	Latitude of the last known location of the inventor.
`inventor_lastknown_longitude`	number	Yes	Longitude of the last known location of the inventor.
`inventor_lastknown_location`	string	No	Location identifier for the last known location of the inventor.
`inventor_first_seen_date`	date	Yes	Date when the inventor was first recorded.
`inventor_last_seen_date`	date	Yes	Date when the inventor was last recorded.
`inventor_years_active`	integer	Yes	Number of years the inventor has been active.
`inventor_num_patents`	integer	Yes	Number of patents associated with the inventor.
`inventor_num_assignees`	integer	Yes	Number of assignees associated with the inventor.
`inventor_years.year`	integer	No	The year in which the patents were recorded.
`inventor_years.num_patents`	integer	No	The number of patents recorded in the specified year.
`inventor_gender_code`	string	No	Code representing the inventor's gender.

curl https://api.patentgrep.com/api/v1/inventor/ \
  -H "X-Api-Key: $PATENTGREP_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "q": {"inventor_id": "example-id"},
    "f": [
      "inventor_id",
      "inventor_name_first",
      "inventor_name_last"
    ],
    "s": [{"inventor_id": "asc"}],
    "o": {"size": 25}
  }'

import os, requests

resp = requests.post(
    "https://api.patentgrep.com/api/v1/inventor/",
    headers={"X-Api-Key": os.environ["PATENTGREP_KEY"]},
    json={
          "q": {"inventor_id": "example-id"},
          "f": [
            "inventor_id",
            "inventor_name_first",
            "inventor_name_last"
          ],
          "s": [{"inventor_id": "asc"}],
          "o": {"size": 25}
        },
)
resp.raise_for_status()
data = resp.json()
print(data)

const res = await fetch("https://api.patentgrep.com/api/v1/inventor/", {
  headers: {
    "X-Api-Key": process.env.PATENTGREP_KEY,
    "Content-Type": "application/json",
  },
  method: "POST",
  body: JSON.stringify({
    "q": {"inventor_id": "example-id"},
    "f": [
      "inventor_id",
      "inventor_name_first",
      "inventor_name_last"
    ],
    "s": [{"inventor_id": "asc"}],
    "o": {"size": 25}
  }),
});
if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);
const data = await res.json();
console.log(data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{
	  "q": {"inventor_id": "example-id"},
	  "f": [
	    "inventor_id",
	    "inventor_name_first",
	    "inventor_name_last"
	  ],
	  "s": [{"inventor_id": "asc"}],
	  "o": {"size": 25}
	}`)

	req, err := http.NewRequest(http.MethodPost, "https://api.patentgrep.com/api/v1/inventor/", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-Api-Key", os.Getenv("PATENTGREP_KEY"))
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	data, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}
	if res.StatusCode != http.StatusOK {
		panic(fmt.Sprintf("%s: %s", res.Status, data))
	}
	fmt.Println(string(data))
}

require "json"
require "net/http"

uri = URI("https://api.patentgrep.com/api/v1/inventor/")

req = Net::HTTP::Post.new(uri)
req["X-Api-Key"] = ENV.fetch("PATENTGREP_KEY")
req["Content-Type"] = "application/json"
req.body = <<~'JSON'
  {
    "q": {"inventor_id": "example-id"},
    "f": [
      "inventor_id",
      "inventor_name_first",
      "inventor_name_last"
    ],
    "s": [{"inventor_id": "asc"}],
    "o": {"size": 25}
  }
JSON

res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(req) }
raise "#{res.code}: #{res.body}" unless res.is_a?(Net::HTTPSuccess)
data = JSON.parse(res.body)
p data

/api/v1/patent/attorney/

POSThttps://api.patentgrep.com/api/v1/patent/attorney/

Rows come back in attorneys. Without f you get attorney_id, attorney_name_first, attorney_name_last. One record by id: GET /api/v1/patent/attorney/{attorney_id}/.

9 fields

Field	Type	Sort	Description
`attorney_id`	string	Yes	Unique identifier for the attorney.
`attorney_name_first`	string	No	First name of the attorney.
`attorney_name_last`	string	No	Last name of the attorney.
`attorney_organization`	string	No	Name of the organization the attorney is associated with.
`attorney_first_seen_date`	date	Yes	Date when the attorney was first recorded.
`attorney_last_seen_date`	date	Yes	Date when the attorney was last recorded.
`attorney_years_active`	integer	Yes	Number of years the attorney has been active.
`attorney_num_patents`	integer	Yes	Number of patents associated with the attorney.
`attorney_num_inventors`	integer	Yes	Number of inventors associated with the attorney.

curl https://api.patentgrep.com/api/v1/patent/attorney/ \
  -H "X-Api-Key: $PATENTGREP_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "q": {"attorney_id": "example-id"},
    "f": [
      "attorney_id",
      "attorney_name_first",
      "attorney_name_last"
    ],
    "s": [{"attorney_id": "asc"}],
    "o": {"size": 25}
  }'

import os, requests

resp = requests.post(
    "https://api.patentgrep.com/api/v1/patent/attorney/",
    headers={"X-Api-Key": os.environ["PATENTGREP_KEY"]},
    json={
          "q": {"attorney_id": "example-id"},
          "f": [
            "attorney_id",
            "attorney_name_first",
            "attorney_name_last"
          ],
          "s": [{"attorney_id": "asc"}],
          "o": {"size": 25}
        },
)
resp.raise_for_status()
data = resp.json()
print(data)

const res = await fetch("https://api.patentgrep.com/api/v1/patent/attorney/", {
  headers: {
    "X-Api-Key": process.env.PATENTGREP_KEY,
    "Content-Type": "application/json",
  },
  method: "POST",
  body: JSON.stringify({
    "q": {"attorney_id": "example-id"},
    "f": [
      "attorney_id",
      "attorney_name_first",
      "attorney_name_last"
    ],
    "s": [{"attorney_id": "asc"}],
    "o": {"size": 25}
  }),
});
if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);
const data = await res.json();
console.log(data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{
	  "q": {"attorney_id": "example-id"},
	  "f": [
	    "attorney_id",
	    "attorney_name_first",
	    "attorney_name_last"
	  ],
	  "s": [{"attorney_id": "asc"}],
	  "o": {"size": 25}
	}`)

	req, err := http.NewRequest(http.MethodPost, "https://api.patentgrep.com/api/v1/patent/attorney/", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-Api-Key", os.Getenv("PATENTGREP_KEY"))
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	data, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}
	if res.StatusCode != http.StatusOK {
		panic(fmt.Sprintf("%s: %s", res.Status, data))
	}
	fmt.Println(string(data))
}

require "json"
require "net/http"

uri = URI("https://api.patentgrep.com/api/v1/patent/attorney/")

req = Net::HTTP::Post.new(uri)
req["X-Api-Key"] = ENV.fetch("PATENTGREP_KEY")
req["Content-Type"] = "application/json"
req.body = <<~'JSON'
  {
    "q": {"attorney_id": "example-id"},
    "f": [
      "attorney_id",
      "attorney_name_first",
      "attorney_name_last"
    ],
    "s": [{"attorney_id": "asc"}],
    "o": {"size": 25}
  }
JSON

res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(req) }
raise "#{res.code}: #{res.body}" unless res.is_a?(Net::HTTPSuccess)
data = JSON.parse(res.body)
p data

/api/v1/location/

POSThttps://api.patentgrep.com/api/v1/location/

Rows come back in locations. Without f you get location_id, location_name, location_state. One record by id: GET /api/v1/location/{location_id}/.

13 fields

Field	Type	Sort	Description
`location_id`	string	Yes	Unique identifier for the location.
`location_name`	string	No	Name of the location (city or place).
`location_state`	string	No	State where the location is situated.
`location_country`	string	No	Country where the location is situated.
`location_county`	string	No	County where the location is situated.
`location_county_fips`	string	No	FIPS code for the county.
`location_state_fips`	string	No	FIPS code for the State.
`location_place_type`	string	No	Type of the place.
`location_latitude`	number	Yes	Latitude of the location.
`location_longitude`	number	Yes	Longitude of the location.
`location_num_assignees`	integer	Yes	Number of assignees associated with the location.
`location_num_inventors`	integer	Yes	Number of inventors associated with the location.
`location_num_patents`	integer	Yes	Number of patents associated with the location.

curl https://api.patentgrep.com/api/v1/location/ \
  -H "X-Api-Key: $PATENTGREP_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "q": {"location_id": "example-id"},
    "f": ["location_id", "location_name", "location_state"],
    "s": [{"location_id": "asc"}],
    "o": {"size": 25}
  }'

import os, requests

resp = requests.post(
    "https://api.patentgrep.com/api/v1/location/",
    headers={"X-Api-Key": os.environ["PATENTGREP_KEY"]},
    json={
          "q": {"location_id": "example-id"},
          "f": ["location_id", "location_name", "location_state"],
          "s": [{"location_id": "asc"}],
          "o": {"size": 25}
        },
)
resp.raise_for_status()
data = resp.json()
print(data)

const res = await fetch("https://api.patentgrep.com/api/v1/location/", {
  headers: {
    "X-Api-Key": process.env.PATENTGREP_KEY,
    "Content-Type": "application/json",
  },
  method: "POST",
  body: JSON.stringify({
    "q": {"location_id": "example-id"},
    "f": ["location_id", "location_name", "location_state"],
    "s": [{"location_id": "asc"}],
    "o": {"size": 25}
  }),
});
if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);
const data = await res.json();
console.log(data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{
	  "q": {"location_id": "example-id"},
	  "f": ["location_id", "location_name", "location_state"],
	  "s": [{"location_id": "asc"}],
	  "o": {"size": 25}
	}`)

	req, err := http.NewRequest(http.MethodPost, "https://api.patentgrep.com/api/v1/location/", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-Api-Key", os.Getenv("PATENTGREP_KEY"))
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	data, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}
	if res.StatusCode != http.StatusOK {
		panic(fmt.Sprintf("%s: %s", res.Status, data))
	}
	fmt.Println(string(data))
}

require "json"
require "net/http"

uri = URI("https://api.patentgrep.com/api/v1/location/")

req = Net::HTTP::Post.new(uri)
req["X-Api-Key"] = ENV.fetch("PATENTGREP_KEY")
req["Content-Type"] = "application/json"
req.body = <<~'JSON'
  {
    "q": {"location_id": "example-id"},
    "f": ["location_id", "location_name", "location_state"],
    "s": [{"location_id": "asc"}],
    "o": {"size": 25}
  }
JSON

res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(req) }
raise "#{res.code}: #{res.body}" unless res.is_a?(Net::HTTPSuccess)
data = JSON.parse(res.body)
p data