Code.gov Getting Started: API Access and First Request (2026)

Getting started overview

Code.gov provides a catalog of open source software developed by U.S. federal agencies, alongside policy guidance for promoting code sharing within government. The primary method for programmatic interaction with Code.gov's data is through its Code.gov API v3. This API is read-only and designed for discovering the metadata of open source projects. Unlike many commercial APIs, Code.gov's public API does not require an account or API keys for making standard GET requests to retrieve data, simplifying the initial setup process.

The API adheres to common web standards, making it accessible through various programming languages and tools. Developers can retrieve information about projects, agencies, and specific releases. Understanding the API's structure and available endpoints is key to effectively querying the catalog. For instance, the API supports filtering and pagination to manage the volume of data returned by requests, which is useful when working with large datasets of government projects.

To begin, developers typically make direct HTTP requests to the API endpoints. This process involves constructing a URL with the desired parameters and then using a client (like curl or a programming language's HTTP library) to send the request and process the JSON response. The Code.gov API documentation details all available endpoints and their expected responses.

Create an account and get keys

For the public Code.gov API (v3) that provides access to the open source project catalog, there is no account creation process, and API keys are not required. The API is designed for public, unauthenticated access to facilitate discovery and reuse of government open source software. This design choice removes a common barrier to entry for developers and researchers who wish to interact with the data.

Developers can directly make HTTP GET requests to the API endpoints without needing to register an application, obtain credentials, or manage API keys. This simplifies the development workflow, as there's no need to handle authentication headers or token refresh mechanisms. The Code.gov documentation on API access explicitly states that authentication is not required for the public API endpoints.

While the public API does not require authentication, it's good practice to review the Code.gov API rate limits to ensure responsible usage and avoid potential temporary blocking due to excessive requests. Adhering to these limits helps maintain service availability for all users.

Your first request

To make your first request to the Code.gov API, you can use a simple HTTP client like curl from your terminal. This example will retrieve a list of projects from the Code.gov catalog.

Using curl

Open your terminal or command prompt and execute the following command:

curl "https://api.code.gov/api/v3/projects"

This command sends a GET request to the /projects endpoint of the Code.gov API. The API will respond with a JSON object containing an array of project entries, along with metadata such as pagination information. Each project entry includes details like the project name, description, agency, and links to its repository.

A successful response will look similar to this (truncated for brevity):

{
  "projects": [
    {
      "agency": "GSA",
      "repositoryURL": "https://github.com/GSA/open-source-policy",
      "name": "Open Source Policy",
      "description": "Policy for Open Sourcing at GSA",
      "status": "Open Source",
      "contact": {
        "email": "[email protected]"
      },
      "permissions": [
        {
          "usageType": "openSource",
          "licenses": [
            {
              "name": "Public Domain",
              "URL": "https://creativecommons.org/publicdomain/zero/1.0/"
            }
          ]
        }
      ],
      "laborHours": 0,
      "tags": [
        "policy",
        "open-source"
      ],
      "vcs": "git",
      "downloadURL": "https://github.com/GSA/open-source-policy/archive/master.zip",
      "organization": "General Services Administration"
    }
    // ... more projects
  ],
  "_metadata": {
    "offset": 0,
    "limit": 10,
    "total": 1234 // Example total
  }
}

This output indicates a successful connection to the Code.gov API and retrieval of project data. The projects array holds individual project objects, and _metadata provides pagination details, which are useful for fetching all available data if more than the default limit exists.

Using a Web Browser

You can also make this first request directly in your web browser. Simply navigate to https://api.code.gov/api/v3/projects. Your browser will display the raw JSON response, often formatted for readability depending on your browser's extensions.

Filtering results

To refine your search, you can add query parameters. For example, to find projects from a specific agency like the General Services Administration (GSA), you can modify your curl request:

curl "https://api.code.gov/api/v3/projects?agency=GSA"

The Code.gov API v3 documentation for projects lists all available query parameters for filtering, sorting, and paginating results.

Common next steps

After successfully making your first request to the Code.gov API, consider these common next steps to further integrate and utilize the data:

1. Explore additional endpoints: The Code.gov API offers more than just the /projects endpoint. Investigate /agencies to retrieve a list of all participating agencies or /releases for specific software releases. Refer to the Code.gov API v3 Reference for a complete list of endpoints and their capabilities.

2. Implement pagination: For applications requiring access to the full dataset, implement pagination using the offset and limit query parameters. This allows you to retrieve data in manageable chunks, respecting the API's rate limits and preventing large responses from overwhelming your application. The _metadata object in the API response provides the total number of items, which can inform your pagination logic.

3. Integrate into an application: Incorporate API calls into a programming language of your choice. Libraries like Python's requests, Node.js's axios, or Java's HttpClient can simplify HTTP requests and JSON parsing. For example, a Python script could fetch projects and store them in a local database or display them on a web page.

4. Data processing and analysis: Once you retrieve data from Code.gov, you can process and analyze it. This might involve filtering projects by license, technology stack, or agency, or performing trend analysis on the types of open source projects being published by the government. Tools for data analysis, such as pandas in Python, can be utilized.

5. Stay informed about API updates: While the Code.gov API is stable, it's beneficial to periodically check the official documentation for any updates, new features, or deprecations. This ensures your integration remains compatible and takes advantage of the latest capabilities.

6. Contribute to open source: If you find a project of interest, consider exploring its repository (linked in the API response) and potentially contributing. The spirit of Code.gov is to foster open source collaboration. Information on how to contribute to open source projects generally can be found on platforms like GitHub's getting started guides.

Troubleshooting the first call

Encountering issues during your first API call is common. Here are some troubleshooting steps for the Code.gov API:

1. Check the URL: Ensure the endpoint URL is correct: https://api.code.gov/api/v3/projects. A common mistake is a typo in the domain or path. Verify against the Code.gov API v3 Reference.

2. Network Connectivity: Confirm your device has an active internet connection and no firewalls or proxies are blocking outgoing HTTP requests to api.code.gov. Try accessing a common website (e.g., Google) to verify general connectivity.

3. HTTP Status Codes: Pay attention to the HTTP status code returned in the response. A 200 OK indicates success. Other common codes include:

   • 400 Bad Request: This usually means there's an issue with your query parameters (e.g., incorrect format, invalid value). Review the API documentation for parameter specifications.
   • 404 Not Found: Indicates the requested resource does not exist. Double-check the URL path.
   • 429 Too Many Requests: You have exceeded the API's rate limit. Wait a period before trying again. The Code.gov documentation on rate limits explains the limits and how to handle them.
   • 5xx Server Error: These indicate a problem on the Code.gov server side. If you encounter a 5xx error, it's often best to wait and retry your request after a short interval.

4. JSON Parsing Errors: If your programming language client is failing to parse the response, ensure the response is indeed valid JSON. Most HTTP libraries will return an error if the content-type header is not application/json or if the body is malformed. Tools like online JSON validators can help inspect the raw output.

5. Browser vs. Command Line: If curl fails, try the URL in a web browser. If the browser displays a JSON response, the issue might be specific to your curl setup or command syntax. If both fail, it points to a network or API service issue.

6. Encoding Issues: When using query parameters with special characters, ensure they are properly URL-encoded. For example, spaces should be %20. Most HTTP clients handle this automatically, but manual construction requires attention to detail. Refer to MDN Web Docs on URL encoding for more information.

7. Consult Documentation: The Code.gov API v3 documentation is the authoritative source for endpoint behavior, expected parameters, and error responses. Reviewing the specific endpoint's documentation can often clarify expected inputs and outputs.