Title: USPTO Proxy
Author: David J. Stein, Esq.
Version: 1.0
Written: Winter, 2005


Abstract: This application is a tool for accessing the database of patents and patent applications hosted by the U.S. Patent & Trademark Office (USPTO). This database is conventionally accessed through the web, which is sufficient (though clumsy) for human-readable access, but inadequate for automated applications that need well-formatted data. The USPTO has made some progress in this regard (see ABX and ePave), but their efforts are focused on delivery of data (via XML) to the USPTO for the submission of a patent application, and not on the disclosure of data from the USPTO for automated analysis.

This application provides a class library (DLL) called USPTOProxy that can be dropped into an application and used as a simple, effective proxy interface for the database. The application can fetch patents and patent applications, with the results returned as structured objects. The application also allows the user to query the database of patents and patent applications with a standard "advanced query" string (e.g., "ttl/neuron and an/merck"), and the user may specify whether the results should be returned as an array of references that match the query or as an array of patent/patent application objects. These operations can be performed synchronously, asynchronously with polling, or asynchronously with event notification. Some fault tolerance has been incorporated for those occasions where the USPTO database is unreachable or unresponsive.

This package also includes a demonstration application; the source code for this application illustrates the usage of the USPTOProxy class, and the executable illustrates the output of the proxy for different operations.

Important Note: The USPTO sets forth policies regarding access to its database (http://www.uspto.gov/patft/help/notices.htm), and enforces those policies by limiting or banning violators' database access privileges. This utility provides access to the USPTO database in the exact same manner as one might access it through the web interface. Hence, any violation of the USPTO policies that a user might commit by manual access can be just as easily committed by the use of this tool. As a user of this software, you bear the responsibility of complying with all USPTO database access policies, and you bear the full consequences if your usage of this tool violates those policies. The author of this software is in no way responsible for the consequences of your use of this software, and you hereby waive the right to seek recourse against the author of this software for all such consequences.

Operation Instructions:

The demonstration application can be viewed simply by running the enclosed executable.

Using the USPTOProxy class in a new C# project is quite easy: just add a reference to the class library (USPTOProxy.dll). It may be convenient also to add "using USPTOProxy_Namespace" to the top of your code module to avoid the need for repeatedly referencing this namespace. This library contains a class called USPTOProxy that contains many public, static methods - i.e., it is not necessary to instantiate it; you may simply call class methods like GetPatent. Some functions are synchronous: the calling thread will block until the result is returned, and since the USPTO database has a latency of several seconds, this may take longer than desired. Other functions are asynchronous: they will return immediately, but the result won't be available until later.

Important Note: In order to utilize this proxy (including any applications that rely on it), you'll need to deal with a small quirk in the Microsoft.Net 1.1 platform. It seems that the web access methods of the platform can't play well with servers that return non-standards-compliant headers for their HTTP communications. Unfortunately, many sites return such non-standards-compliant headers... including the USPTO webserver. As a result, web accesses are likely to fail with an exception and return an error message instead of providing the desired results. This scenario is likely to persist until (at least) the .Net 2.0 platform is released.

The solution is to tell the .Net 1.1 platform not to be so picky - i.e., not to throw an exception or complain when such non-standards-compliant headers are returned. There are at least two ways of accomplishing this step - unfortunately, neither is terribly elegant:

The following functions are available:

All of these functions operate on the USPTO patent database. Equivalent functions are available for published patent applications:

Code Examples:


// Functions for fetching patents


  // Synchronous (blocking) call to fetch a Patent object
Patent patent = USPTOProxy.GetPatent("1234567");

  // Asynchronous call with polling to fetch a Patent object
GetPatentAsync patentSearch = USPTOProxy.GetPatent_Start("1234567", null);
  // later...
if (patentSearch.searchStatus == SearchStatusEnum.Complete)
  Patent patent = patentSearch.Patent;

  // Asynchronous call with event handler to fetch a Patent object
public void ProcessPatent(string strSerial, Patent patent) { ... }    // this is our event handler function
USPTOProxy.GetPatent_Start("1234567", new GetPatentCompleteDelegate(ProcessPatent));

  // Asynchronous call with polling to query the database for patents
QueryPatentsAsync patentQuery = USPTOProxy.QueryPatents_Start("ttl/neuron and an/cleveland clinic", null, QueryResultsFormatEnum.ReferencesOnly);
  // later...
if (patentQuery.searchStatus == SearchStatusEnum.Complete) {
  foreach (QueryResult result in patentQuery.arrayQueryResults) {
    string strSerial = result.strSerial;
    string strTitle = result.strTitle;
  }
}

  // Asynchronous call with event handler to query the database for patents
public void ProcessPatentQueryResults(string strQuery, QueryResultsFormatEnum queryResultsFormat, ArrayList arrayQueryResults) { ... }  // this is our event handler function
USPTOProxy.QueryPatents_Start("ttl/neuron and an/cleveland clinic", QueryResultsFormatEnum.ReferencesOnly, new QueryPatentsCompleteDelegate(ProcessPatentQueryResults));

  // Synchronous (blocking) call to determine date of last update of patent database
string strDate = USPTOProxy.GetPatentDatabaseFreshness();


// Similar functions for fetching patent applications


  // Synchronous (blocking) call to fetch a PatentApplication object
PatentApplication patentApplication = USPTOProxy.GetPatentApplication("20050000001");

  // Asynchronous call with polling to fetch a PatentApplication object
PatentApplicationSearchObject patentApplicationSearch = USPTOProxy.GetPatentApplication_Start("20050000001", null);
  // later...
if (patentApplicationSearch.Status == USPTOProxyStatus.Complete)
  PatentApplication patentApplication = patentApplicationSearch.PatentApplication;

  // Asynchronous call with event handler to fetch a PatentApplication object
public void ProcessPatentApplication(string strSerial, PatentApplication patentApplication) { ... }    // this is our event handler function
USPTOProxy.GetPatentApplication_Start("20050000001", new GetPatentApplicationCompleteDelegate(ProcessPatentApplication));

  // Asynchronous call with polling to query the database for patent applications
QueryPatentApplicationsAsync patentApplicationQuery = USPTOProxy.QueryPatentApplications_Start("ttl/neuron and an/cleveland clinic", null, QueryResultsFormatEnum.ReferencesOnly);
if (patentApplicationQuery.searchStatus == SearchStatusEnum.Complete) {
  foreach (QueryResult result in patentQuery.arrayQueryResults) {
    string strSerial = result.strSerial;
    string strTitle = result.strTitle;
  }
}

  // Asynchronous call with event handler to query the database for patent applications
public void ProcessPatentApplicationQueryResults(string strQuery, QueryResultsFormatEnum queryResultsFormat, ArrayList arrayQueryResults) { ... }  // this is our event handler function
USPTOProxy.QueryPatentApplications_Start("ttl/neuron and an/cleveland clinic", QueryResultsFormatEnum.ReferencesOnly, new QueryPatentApplicationsDelegate(ProcessPatentApplicationQueryResults));

  // Synchronous (blocking) call to determine date of last update of patent application database
string strDate = USPTOProxy.GetPatentApplicationDatabaseFreshness();

Comments: This application was cobbled together from code assembled during several prior coding projects that operated on the USPTO database. All of the query functions were substantially improved and expanded upon in order to provide a reliable, general-purpose proxy.

Application History: This program was written in Winter, 2005. If the patent law software development community demonstrates sufficient interest in this application (or if I just find myself with extra time on my hands), I may expand its functionality - e.g.: data fields for priority applications; similar functions for accessing the USPTO trademarks database; and XML output of patents and patent applications to match the USPTO ABX XML schema.

Questions/Comments: Please contact David J. Stein, Esq. via email at djs10@po.cwru.edu.

Terms and Conditions of Use: Please see the enclosed "License.html" file for terms and conditions of use of this software package.