Closure Compiler Service API Reference

Closure compiler service is deprecated, and will be removed. Please consider running the compiler locally instead.


To request compiled code or other information from the Closure Compiler service, you must send an HTTP POST request to the URL The body of the request must contain the parameters listed in Required Request Parameters, and it can also contain any of the optional parameters listed in Optional Request Parameters.

When possible, this page defers to the canonical documentation for command line options at Flags and Options. Command line options not available in the webservice are not documented here. Some request parameters are also not available on the command line or have a different name.

If the server fails to process your request, you will receive a server error message. These messages are described in the Error Messages section.

Request Parameters

Required Request Parameters

js_code or code_url

The JavaScript to be compiled. You must include at least one of these parameters, and you can include both.

The js_code parameter must be a string containing JavaScript, such as alert('hello').

The code_url parameter must contain the URL of a JavaScript file. You can include multiple code_url parameters to specify multiple input files.


See documentation for compilation_level at Flags and Options.

The format for the Closure Compiler service's output. There are three possible output formats:

The xml output format wraps the requested information in valid XML.

The XML output looks like this:

          <compiledCode>var a="hello";alert(a);</compiledCode>

The compiledCode section contains the compressed JavaScript that the Closure Compiler service produced. This section only appears if you include an output_info parameter with a value of compiled_code in the request. Similarly, the statistics section only appears if you include an output_info parameter with a value of statistics.

If you include an output_info parameter with a value of warnings and the compiler produces a warning, the output will include a warnings tag:

           <warning type="JSC_NO_SIDE_EFFECT" file="default.js" lineno="12" charno="3"  line="delete 1;">warning 1</warning>
           <warning type="JSC_UNUSED_VAR" file="default.js" lineno="13" charno="13" line="delete 1;">warning 2 </warning>

If you include an output_info with a value of errors, the Closure Compiler service will include an errors tag if your code contains a syntax error or other problem that prevents compilation. The errors tag looks like this:

            <error type="JSC_NO_SIDE_EFFECT" file="default.js" lineno="12" charno="3"  line="var x=-'hello';">error 1 </error>
            <error type="JSC_UNUSED_VAR" file="default.js" lineno="13" charno="13" line="var x=-'hello'">error 2 </error>

The file, line, and col attributes of the error and warning tags indicate where the Closure Compiler service encountered the error.

If the Closure Compiler service encounters an error that prevents the processing of your input, the output looks like this:

            <error code="1">Over quota</error>

The json output format wraps the requested information in a JavaScript Object Notation (JSON) string. Evaluation of this string as JavaScript returns a JavaScript Object.

The JSON output looks like this:

"compiledCode":/* raw code here */,
{"errors": [
   "error":"ERROR: You failed.",
   "line":"var x=-'hello';"}],
"warnings": [
   "warning":"Warning: You did something wrong!",
   "line":"delete 1;"}]
  {"code":123,"error":"Over quota"}

The JSON format is similar to the XML format: every tag in the XML output corresponds to a property of the same name in the JSON object

The text output format returns raw text without tags or JSON brackets. If the output_info includes compiled_code, the text contains JavaScript. If the output_info includes warnings, the text contains warning messages. If the output_info includes statistics, the text contains statistics.

The output_format parameter defaults to a value of text.


Indicates the kind of output you want from the compiler. There are four possible kinds of output:

A compressed and optimized version of your input JavaScript.
Messages that indicate possible bugs in your JavaScript.
Messages that indicate syntax errors or other errors in your JavaScript.

Information about the degree of compression that the Closure Compiler achieves. For xml output, the Closure Compiler service returns statistics in the following format:


Optional Request Parameters


The value of this parameter must be JavaScript code that declares function names or other symbols. Use js_externs to preserve symbols that are defined outside of the code you are compiling. The js_externs parameter only has an effect if you are using a compilation_level of ADVANCED_OPTIMIZATIONS. See Advanced Compilation for more information.


The value of this parameter must be the URL of a file containing JavaScript that declares function names or other symbols. The symbols declared in this file are preserved in exactly the same way as symbols listed directly in the js_externs parameter. The externs_url parameter only has an effect if you are using a compilation_level of ADVANCED_OPTIMIZATIONS. See Advanced Compilation for more information.

You can specify this parameter multiple times if you have multiple externs files.


By default, the Closure Compiler service uses a standard externs file that declares common externally defined symbols like document and all its methods. If you do NOT want to use these common externs, include in your request an exclude_default_externs parameter with a value of true.

See Advanced Compilation and Externs for more information about externs.


If present, the Closure Compiler service caches the compiled code for one hour and makes it available through a special URL. During this hour you can test the compiled code by pointing your browser to this URL. The URL has this form:[value of output_file_name]


See documentation for formatting at Flags and Options. You can provide multiple formatting parameters in the same request.


If you give the use_closure_library parameter a value of true, the compiler looks for goog.require() statements in the source code and supplies the Closure Library code requested by any such statements. It also performs optimizations designed specifically for Closure Library code. See the Closure Library documentation for more information about the Closure Library. See Finding Your Way around the Closure Library for more information about the goog.require() function.

The use_closure_library parameter defaults to false.


See documentation for warning_level at Flags and Options.


See documentation for equivalent language_in option at Flags and Options.


See documentation for language_out at Flags and Options.


See documentation for rewrite_polyfills at Flags and Options.


See documentation for use_types_for_optimization at Flags and Options.

Error Messages

If the server fails to process your request, you will receive one of the server error messages listed in the table below. Note that these server error messages are different from compiler errors and warnings. Compiler errors and warnings indicate that Closure Compiler found a problem in your JavaScript code. Server error messages indicate that the compiler is not able to process your code at all because of an error in your request.

Error CodeError MessageMeaning
2Unknown output mode.The value of the output_format parameter is something other than xml, json, or text.
4Unknown compression level.The value of the compilation_level parameter is something other than WHITESPACE_ONLY, SIMPLE_OPTIMIZATIONS, or ADVANCED_OPTIMIZATIONS.
8POST data too large. The size of the data you sent to the Closure Compiler service exceeds 200,000 bytes. Both the Compiler Service UI and your API calls use an HTTP POST request to communicate with the service, and the total amount of data sent in this request cannot exceed 200,000 bytes. For API calls, this limit applies to the total amount of text in all request parameters. For the Closure Compiler UI, this limit applies to the total amount of text in both the source code and the compiler options like @code_url. If your request is too big, either move source code into separate files and reference them using @code_url, or use the Closure Compiler application on your local machine.
9File too large.The total amount of code from all code_url files, all externs_url files, all js_code code and all js_externs code exceeds 1024000 bytes.
10Cannot retrieve content from URL.An error occurred when the Closure Compiler service tried to retrieve either a JavaScript file indicated in the code_url parameter or an externs file indicated in the externs_url parameter. Check that the URL is correct and that the permissions of the file allow it to be viewed.
12URL is not formed properly.The value of either the code_url parameter or the externs_url parameter is not a well-formed URL.
13No output information to produce, yet compilation was requested. No output_info parameter has been specified.
14Unknown output_info valueThe value of an output_info parameter is something other than compiled_code, warnings, or statistics.
16Unknown warning levelThe value of the warning_level parameter is something other than QUIET, DEFAULT, or VERBOSE.
17Unknown formatting option.The value of the formatting parameter is something other than pretty_print.
18Unknown parameter in HTTP requestThe HTTP request contains a parameter other than one of the ones listed in this document.
19Illegal value for output_file_name The output file name contains a character a number, letter, dot, underscore, or dash, or it contains two consecutive dots (..)
22Too many compiles performed recently. Try again later. You have submitted too many compiles from your machine. After an hour, you should be able to perform compiles again.
23Compiler exception (with backtrace) The compiler crashed. The text of the error will contain information to help Google debug the problem.
24Unsupported input resource type The resource type is not http:, and so the input file will not be retrieved.