The bargain envisioned in the United States Constitution is that inventors disclose how to practice an invention, making the knowledge available to the world, in exchange for a time-limited monopoly. Such a disclosure would be useless if it were not made available to the public. Similarly, it is common for people reviewing an issued patent to ignore the “prosecution history” — even though the prosecution history often lays out weaknesses in the claims or, more frequently, involves concessions made by the inventor as part of getting the patent issued.
For example, a claim that says “We do X in conjunction with widgets A, B, and C” may have as part of the prosecution history a document where the inventor’s lawyer states something like “in order to overcome the cited art, we clarify in these claims that X must be directly done using widgets A, B, and C”. Such a statement would limit or eliminate the ability to argue that “in conjunction with” does not require direct use, so the claim covers any device that involves A, B and C where C is present but X is done without C’s direct use.
This kind of limiting effect of the prosecution history is sometimes referred to as “prosecution estoppel”, but leaving aside the Latin words and legalize really means “you can’t say the claims mean one thing during prosecution of the patent and a different thing after issuance”.
To find patents, applications, prosecution history, and the name of the current owners, one needs only an internet connected device.
To find issued patents, we can search the original source at the US Patent and Trademark Office (“USPTO”) by visiting http://patft.uspto.gov/netahtml/PTO/search-bool.html. New patents issue at midnight Eastern time every Tuesday (so Monday night at 9 pm on the West Coast). It is not unusual to have data mining operations hitting the USPTO’s servers hard right after patent issuance happens so you may need to be patient in trying to do that search. The other source for issued patents is https://patents.google.com/, a site that allows you to search for patents that are several weeks to several months old or older. Of course, Google’s site allows you to download an actual image of the issued patent whereas the USPTO’s site requires you to download it page by page (and let’s be serious, nobody is downloading a 50 page patent that way). There are services that allow you to do so, though, such as https://www.pat2pdf.org/, a site that allows downloads as soon as the patent issues.
Similar resources exist for pending applications. Patent applications are published at midnight Eastern time on Thursday (9 pm Wednesday night on the West Coast). The USPTO has a search facility at http://appft.uspto.gov/netahtml/PTO/search-bool.html. If you don’t need the most up to date list of patent applications, you can use https://patents.google.com/. Note that the same issues exist regarding how busy the servers get right after publication happens.
If you know how to program PERL, I’ve included source code at the end of the article that allows you to perform your own conversion of a patent or patent application into a single PDF.
To find the owner of a patent or patent application, one can access the patent assignments database. There are a lot of legal terms related to assignments (“bonafide purchaser for value”, anyone?), but the basic things to remember are:
(1) The USPTO has errors in the assignments database. Some of these are data entry or other errors by the USPTO. Others are errors by lawyers for other inventors in entering data. Either way, you’ll want to review the underlying assignment documents before buying or licensing a patent.
(2) Assignments should be recorded. If an assignment is not recorded, the last recorded owner of the patent (or if no assignment is recorded, the inventor or applicant) can be (pretty) safely assumed to have the right to sell or license the patent unless the buyer or licensee knows that there has been another assignment that wasn’t recorded. Assignments that happen but aren’t recorded can create what is known in the art as “a horrible mess that can and probably does cost a fortune to straighten out, and sometimes can’t be straightened out”.
(3) Assignment obligations are subject to state law. What this means is that if the statute of limitations on a written contract is 6 years and you have a contract that says “I agree that I will assign my patent to you”, you have only until the statute of limitations runs out to compel such an assignment. After that passes, you are out of luck. See Stanford v Roche, 563 U.S. 776 (2011) or the discussion about it on Patently-O. Prior to the Stanford case it was pretty common to see contract language that said “I agree I will assign …”. After the Stanford case, contracts were rewritten across many industries to say “I shall and hereby do assign …”. It is quite possible that companies have tried to circumvent this case (or simply are unaware of it), leading them to record a contract where an assignment is promised. Such a filing is unlikely to create an effective assignment. The bottom line is you should probably have a lawyer look at the assignment history of the patent before assuming that you know the identity of the current owner.
Finally, we come to the file wrapper. After navigating a somewhat annoying CAPTCHA, https://portal.uspto.gov/pair/PublicPair allows you to search for the prosecution history of patents and pending patents.
Let’s walk through the prosecution history for a drug patent. One application number in that family is 07/882,988. We visit https://portal.uspto.gov/pair/PublicPair and search for that application number:
When you hit search, you may discover one of the dirty secrets about the US patent office: They are using some very outdated technology and just can’t keep up with demand for access to prosecution histories. As a result, you may get an error message saying it isn’t available for that application, that it is too busy, that there is a database error, etc. These error messages are almost always transient and resolve within minutes (sometimes) or hours.
Having run the search (and been lucky enough that the system returned data instead of an error), we get this result:
The fields on the “Application Data” tab are pretty self-explanatory.
We next hit the “Transaction History” tab.
Transaction history tells you (almost) everything that has happened during the life of the application. In this case, we can see that there was FDA involvement, the issue notification was sent 8/31/1993, the patent term extension certificate issued 7/11/2002, etc.
A list is fine, but how do we find the referenced documents? Easy — we hit the “Image File Wrapper” tab. If we hit checkbox next to the “PDF” button and then hit the PDF button, it will generate a single PDF with the entire prosecution history in it. You can download the history in a single file this way.
Critically, you should note that the status on the “Application Data” tab, the most recent status in the “Transaction History” tab and the latest in the “Image File Wrapper” tab sometimes don’t match. It is not uncommon, for example, to see “Issue Notification” on the transaction history tab, a “-” in the status field on the “Application Data” tab, and no reference to an issue notification in the Image File Wrapper tab. Since issue notices are handed down on Wednesdays, this is a reproducible bug (although it manifests in situations other than issue notices as well). It is important to review all three tabs to be sure you know the actual status of the patent application.
To find if there are other applications or issued patents in the family, we hit the “Continuity Data” tab.
From that tab, we can see that the issued patent has two children and an abandoned (non-patented) parent. Why was the parent abandoned? Perhaps the examiner cited a reference in that application that can be used to invalidate some of the claims in the children. Perhaps the company hoped to get a different examiner. To figure out what is really going on, you will need to review the prosecution history of the parent and children applications.
The “Foreign Priority” tab often does not appear as there is no foreign priority claim. If there is one, it can be found under that tab (although again, read the file wrapper as there is no guarantee that the data on foreign priority was entered correctly).
The “Fees” tab takes you to the maintenance fee page. The “Published Documents” tab takes you to the text-formatted published applications or patents (the same ones we showed you how to find earlier in the article).
“Address & Attorney/Agent” is self-explanatory.
The “Assignments” tab is another way to approach finding assignments.
Finally, the “Display References” tab is where publications referenced in the file history can be found (but they can often also be found in the Image File Wrapper tab).
In no way is this an endorsement of trying to work your way through a legal decision on patents yourself. Enforcing, purchasing, licensing, challenging or otherwise interacting with patents is complex and a lawyer’s help is well worth the investment. Reading the file history, however, is a great way to make sure your time with the lawyer is spent productively.
*****
PERL code to convert patent applications or issued patents to a PDF (written on Windows, not tested on Linux or Mac):
use strict;
use LWP::UserAgent;
use PDF::API2;
use List::Util qw( reduce );
unless (-d “C:\\cgi\\tmp”) {
system(“md C:\\cgi\\tmp”)
}
my($username)=getlogin || getpwuid($<);
my($urlbase)=’http://pdfpiw.uspto.gov/.piw?Docid=07777777&homeurl=http%3A%2F%2Fpatft.uspto.gov%2Fnetacgi%2Fnph-Parser%3FSect1%3DPTO1%2526Sect2%3DHITOFF%2526d%3DPALL%2526p%3D1%2526u%3D%25252Fnetahtml%25252FPTO%25252Fsrchnum.htm%2526r%3D1%2526f%3DG%2526l%3D50%2526s1%3D7777777.PN.%2526OS%3DPN%2F7777777%2526RS%3DPN%2F7777777&PageNum=&Rtype=&SectionNum=&idkey=NONE&Input=View+first+page’;
my($patnum)=$ARGV[0];
unless (length($patnum)>2) {
print “Enter patent number:”;
$patnum=<STDIN>;
chomp($patnum);
}
$patnum=~ s/\,//g;
unless ( ($patnum=~ m/^\d\d\d\d\d\d\d$/) || ($patnum=~ m/^\d\d\d\d\d\d\d\d$/) ) {
print “$patnum is not a patent number”;
exit;
}
$urlbase=~ s/7777777/$patnum/g;
my($result)=grab($urlbase);
if ($result=~m/^error/i) {
print “Error on try of $urlbase\nGot $result”;
exit;
}
$result=~ m/\<embed src\=\”(http\:\/\/pdfpiw.uspto.gov\/\d\d\/\d\d\d\/\d\d\d\/)1.pdf”/i;
my($base)=$1;
print “Found $base\n”;
my($going)=1;
my($basepath)=”C:\\cgi\\tmp\\”;
my(@files);
while($going > 0) {
my($path)=$basepath . “$patnum” . “_” . $going . “.pdf”;
my($base2)=$base . $going . “.pdf”;
print $base2 . “\n”;
my($result2)=grab($base2);
if ($result2=~ m/^error/i) {
if ($going==1) {
print “Got $result2 on trying $base2”;
exit;
}
$going=0;
}
else {
print “writing $path\n”;
open(OUT,”>$path”);
binmode(OUT);
print OUT $result2;
close(OUT);
$going++;
push(@files,$path);
}
}
# Given two pdfs and a page number, appends the given page of the second pdf to the first pdf
sub append_page_to_pdf {
my ( $pdf1, $pdf2, $pg ) = @_;
$pdf1->importpage( $pdf2, $pg );
}
# Given two pdfs, appends the second to the first. Closes pdf2
sub merge_2_pdfs {
my ($pdf1, $pdf2) = @_;
map &append_page_to_pdf( $pdf1, $pdf2, $_ ), 1..$pdf2->pages;
$pdf2->end;
return $pdf1;
}
# does what it says
sub open_pdf {
my $file = $_[0];
my $pdf = PDF::API2->open( $file );
print “Opened pdf ( $file )\n”;
return $pdf;
}
# reduces merge_2_pdfs over an array of pdfs
sub merge_pdfs {
my @files = @_;
my $starting_filename = shift @files;
my $start_pdf = &open_pdf( $starting_filename );
my $final_pdf = reduce { &merge_2_pdfs( $a, &open_pdf( $b ) ) } $start_pdf, @files;
return $final_pdf;
}
# Get the arguments ie save_name, file1, file2, file3, …
my $save_name=”C:\\users\\” . $username . “\\desktop\\” . “patent” . $patnum . “.pdf”;
print “saving to $save_name\n”;
my $save = &merge_pdfs( @files );
$save->saveas( $save_name );
exit;
sub grab {
my($sname)=$_[0];
my($url)=$sname;
# create a UserAgent
my ($agent_name)=”PPMOD-Agent/LWP”;
$agent_name=”Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; AskTB5.6″;
my ($ua) = LWP::UserAgent->new($agent_name);
$ua->timeout(30);
my ($request) = HTTP::Request->new(GET => $url);
#add an Accept header
$request->header(Accept => ‘text/html’);
$request->header(Accept => ‘*/*’);
my ($response) = $ua->request($request);
if ($response->is_success) {
return (($response->content));
} else {
return ( “Error: ” . $response->status_line . “\n” );
}
}