by Robert A. Esposito
With the software copyright case Google LLC, v. Oracle America, Inc. now being decided by the Supreme Court after hearing oral arguments on October 7, 2020, software developers and the general public may wonder about the potential impact a decision in the case may have on the tech industry. At stake for the parties are the copyright protections afforded to Oracle’s application programing interface (API) previously used by Google to provide the functionality of Google’s highly popular Android mobile operating system installed on billions of mobile devices worldwide.
The outcome may have wide-reaching implications regarding access to important tools of the trade for many software developers. Without a balanced ruling, an uncertain road could lie ahead for the software industry, with the potential to impact innovation and consumers for years to come.
An API is a set of tools used by software developers for accessing and using predefined software functions when building software applications. Software development platforms provide APIs along with collections of various software functions in libraries to software developers for use in the development process. For example, if a software developer wanted build a software application for a mobile operating system (e.g. Apple iOS, Android, etc.) that controls a smartphone camera to capture an image, the software application must be able to control the smartphone camera. A software developer could write the code necessary to develop their own camera function for controlling the smartphone camera. But rather than writing the code from scratch, the developer may instead use the API provided by the mobile operating system to execute the operating system’s predefined camera function.
While the software development industry has long considered software for performing various functions to be copyright-protectable due to the wide variety of ways in which those functions can be expressed differently and uniquely by the author of the software code, developers have traditionally taken the position that copyright protections did not extend to the API counterparts of such software, due to the functional nature of API code and the limited number of options for expressing the code to perform those functions. In fact, APIs have traditionally been shared freely among software developers to foster interoperability between different software platforms.
In the case at hand, Google wanted to enhance its Android mobile operating system to include Oracle’s Java Standard Edition libraries which are widely used by software developers around the world. Google initially negotiated with Oracle to license the software. However, when licensing talks failed, Google created its own version of Oracle’s Java Standard Edition libraries. In doing so, Google copied a core part of Oracle’s API code (i.e. the interface to access functions in the libraries).
Oracle sued Google for copyright infringement. After a series of rulings from the District Court for the Northern District of California and the United States Court of Appeals for the Federal Circuit, Google was ultimately found to have infringed Oracle’s API copyright.
The case is now before the Supreme Court of the United States. The questions presented include: (1) whether APIs are copyrightable under 17 U.S.C. §102, and (2) whether Google’s use of Oracle’s API was permissible under the Fair-Use exception 17 U.S.C. §107 of copyright law.
Google argues that:
1. API’s are not copyrightable, because:
(a.) An API is simply a “method of operation” (i.e. a way to declare the code) which is not protectable under copyright law, and
(b.) Since there are only a limited number of ways to implement API declarations, a copyright on an API would effectively copyright the very idea of the API functionality itself, which is impermissible under the merger doctrine of copyright law, and
2. Even if APIs are copyrightable, Google’s use of Oracle’s API was permissible under the Fair-Use exception because:
(a.) Under the first Fair-Use Factor (The Purpose and Character of the Use), although Google used Oracle’s API for commercial use, the use was transformative because it added something new by allowing Java developers around the world to use create innovative programs on a smartphone platform as opposed to a traditional desktop platform;
(b.) Under the second Fair-Use Factor (The Nature of the Copyrighted Work), Oracle’s API is purely functional (not creative), because it is merely a mechanism to call software functions;
(c.) Under the third Fair-Use Factor (The Amount of Substantiality of the Reuse), Google used a mere 0.5% of Oracle’s code; and
(d.) Under the fourth Fair-Use Factor (The Effect on the Market for, or Value of, the Original Work), Oracle’s bottom line was not harmed, because Oracle was not a player in the smartphone market.
Conversely, Oracle argues that:
1. API’s are copyrightable, because:
(a.) An API is not simply a “method of operation” (i.e. a way to declare the code), but rather an elegant arrangement of code that provides an interface to functions, and are therefore just as copyrightable as the functions they call, and
(b.) The merger doctrine is inapplicable, because there are a countless number of ways to implement API declarations. Copying the API declarations was not necessary.
2. Google’s use of Oracle’s (copyrightable) API is not allowed under the Fair-Use exception because:
(a.) Under the first Fair-Use Factor (The Purpose and Character of the Use), Google used Oracle’s API for commercial use, and the use was not transformative, because it is not possible to add something new by merely copying the code for the same purpose;
(b.) Under the second Fair-Use Factor (The Nature of the Copyrighted Work), Oracle’s API is creative, because it was specifically designed in a unique manner that is appealing and memorable to developers;
(c.) Under the third Fair-Use Factor (The Amount of Substantiality of the Reuse), Google copied the 11,330 lines of Oracle’s code that are most critical in creating derivative works; and
(d.) Under the fourth Fair-Use Factor (The Effect on the Market for, or Value of, the Original Work), Oracle’s current market was harmed, because, licenses with Amazon and other clients were negatively affected, and Oracle’s potential markets where harmed because Oracle wanted to be a player in the smartphone market.
The Court’s ruling in this case will likely have a downstream impact extending beyond the parties involved.
For example, although Android has since moved away from Oracle’s API and is currently using Oracle’s open source platform OpenJDK, Google could still be on the line for significant damages to the tune of $9 Billion. Google’s Android platform currently supports roughly 2.5 billion Android devices, which account for roughly 80% of the market share. The number of Android devices and their market share is expected to increase in the coming years. In order to subsidize the cost of such large damages and legal fees, while maintaining profitability, Google is likely to pass these costs onto its customers. Although this may be accomplished by increased costs to entities that advertise through Google (i.e. Google’s primary source of revenue), it is also likely that Android users may bear some of the burden through increased costs in mobile devices and services. This may affect the ability of Android-based mobile device makers from continuing to distinguish their products from those of competitors (such as Apple) based on a lower price point.
The general implications of a ruling in favor of Oracle may also have significant commercial impact. Prior to the dispute between Google and Oracle, APIs were widely shared by developers to provide interoperability between different platforms. This sharing has helped the application software industry and mobile device industry achieve significant innovation and growth over the past 10 years. A ruling in favor of Oracle could result in opportunistic API developers holding other software innovators hostage in licensing negotiations for use of their API. This may be problematic for various reasons. On one hand, if software innovators refuse to agree to the API license, they will have to develop their own API, which is time consuming and expensive. This may be harmful to smaller startup companies. In addition, if every developer has to develop its own unique API, systems may lose interoperability with one another. This may ultimately slow down the software development and innovation that have contributed to the success of the mobile device and application software industries. On the other hand, if software innovators agree to an API license, they may be subject to exorbitant fees or restrictions on API use that may hurt their growth and autonomy. This may result in too much power being given to powerful developers over potential competitors, effectively producing a monopoly that could stifle innovation and competition.
A ruling in favor of Google may also have negative implications. Oracle’s API is widely relied upon, due to Java’s worldwide popularity in Oracle’s standard JDK platform, which Oracle currently licenses to Java developers worldwide. The value of the JDK license could take a hit if Oracle receives an adverse judgment, because weaker copyright protection may lead to competitors developing competing Java platforms using Oracle’s API. A ruling in favor of Google could also open the door to more copyright challenges to other features of Oracle’s JDK, further eroding Oracle’s market.
More generally, the copyrights of API software developers may be weakened across the board. For example, competitors would have incentives to copy and use each other’s code more freely without fear of repercussions under copyright law. Startups would benefit from free use of the significant work of industry leaders, while larger industry leaders could steal innovative works from smaller startups to further entrench their market share.
HOPES FOR CLARITY MOVING FORWARD
The clearest path forward may be for the Court to hold that APIs are not eligible for copyright protection. Such a ruling would preserve the long-standing understanding among software developers that APIs can and should be shared freely. Software developers would continue to enjoy protection for their software code as a whole, but not for functional APIs. Such a holding could be narrowly tailored in adjudging the APIs not eligible for copyright protection, without implicating the copyright protection conferred for other aspects of Oracle JDK platforms.
However, if the Court holds that APIs are eligible for copyright protection, the Court could still balance the rights of API copyright holders and software developers by carving out a fair use exception for use of APIs under certain circumstances. For example, if the Court places more weight on the first Fair-Use Factor (The Purpose and Character of the Use) and the fourth Fair-Use Factor (The Effect on the Market for, or Value of, the Original Work), fair use of APIs could be considered permissible as long as the use is not for the primary purpose of developing a product that will mimic and replicate the copyright holder’s product. Such a ruling could provide a line in the sand for copyright holders and developers to understand what is allowed and what is off limits when using a competitor’s API. Without such clarity, the software industry could be in flux for years to come.