Develop A Solar Application

Our big-data geomatics platform contains a wealth of site-specific information on tens of millions of individual properties, derived from high-resolution solar energy simulations. You can put our data to work through our Solar Application Programming Interface (Solar API) to create new Web and mobile solar energy applications.

Building A Solar Application


The development of the Solar Profile, widgets, and the API were funded in part by a DOE SunShot Award

Developer Terms and Conditions

Introduction To The Solar Profile

Every property has a Solar Profile. A Solar Profile is the quantification of the economic and environmental benefits of the energy produced by solar panels installed on the site. We determine these benefits through the following computationally intensive processes:

  1. Place virtual solar panels in a 3D world derived from LiDAR (measurements from lasers mounted on fixed-wing aircraft)
  2. Run a full simulation of the sunlight intensity on each square meter of rooftop surface area, based on typical weather, shadows (near and far horizon), slope and orientation
  3. Draw a polygon representing the buildable area by delineating the contiguous pixels with sufficient sunlight
  4. Fit panels into the polygon to produce a default system size
  5. Compute the energy production for the life of the panels, based on sunlight, efficiency and performance degradation
  6. Determine the levelized cost of energy (LCOE) based on the installed cash price of the system
  7. Calculate the avoided grid electricity costs based on the energy usage (load profile), utility rates, statewide energy inflation rates and applicable incentives
  8. Determine the amount of carbon equivalent emissions avoided through solar energy generation based on the regional grid

In some cases, LiDAR is not available, so our information is derived from Digital Surface Models (DSMs) that have been produced from stereo imagery, as well as four-band imagery that helps to classify vegetation and impermeable surfaces so we can avoid trees and place panels on rooftops. These are not as precise as LiDAR measurements. When there is no 3D data available, the information for the record is based on a 10 kilometer grid, and all the properties within that grid will have the same information. The data related to these interpolated sites are less reliable than the stereo-imagery based DSMs or the LiDAR-based DSMs, but they are still useful for initial calculations.

The result of this simulation is an instant property-level solar model that will be refined through the following successive stages:

  1. Estimate. By interacting with the model to change the system size, installed cost per Watt, intensity of sunlight, or other factors, you can refine the estimated benefits of installing solar panels. The simulation can apply various financing plans, such as leases, loans and PPAs at different rates and terms to understand the relative benefits.
  2. Design. Once a system design if complete, data on equipment elements such as solar panels, inverters and racking will be added to the Solar Profile. These will be applied to further refine the solar benefits, based on both the costs and performance. The designed components can be discovered once the Solar Profile has reached this stage.
  3. Install. When the Solar Profile is in the installation stage, data related to the contractor that will be installing the solar panels is added to the Solar Profile.
  4. Generation. Once the installation is complete, and the solar energy system is generating electricity, the Solar Profile can be queried for historical system performance as well as installed equipment, the installer, the installed cost per Watt, commission date and other factors.

The result is a platform with valuable data for the full lifecycle of solar projects that can be accessed through an API for new, unique solar applications in such fields as solar finance, sales and marketing, ratings, securities, installation, permitting, incentives development, real estate and emissions reduction. If it involves solar energy, Geostellar has the data and interfaces you’ll need for your program.

We look forward to seeing what you create!

Getting Started On A Solar Application

Register for your Geostellar Developer Account

Our API is available to professional software developers, hobbyists, solar installers, equipment distributors, financing companies, rating agencies, analysts, utilities, public administrators, solar sales and marketing organizations, non-profits, researchers, educators and other individuals and groups. Initially, all developers will receive a test account geographically limited to Washington, DC with a limitation on the number of queries to 10,000. Your usage will be governed by the Geostellar Solar Application Development Terms & Conditions. A Commercial or Academic License will be required for to access the full data set and to publish your Solar Application on the Geostellar platform. This might involve either a licensing fee or a partnership agreement. Free academic and research licenses are also available. Once you’ve registered, a developer relations associate will contact you to work out the proper license.

Register as a developer

Your API Key

Once you are registered, you’ll see your API key here:Your API Key

Add the API Key as a url param `api_key`.

Building a Search String

To build a search string, simply attach the address to look up and your API Key to a URL pointing at Geostellar: { Search Address } &api;_key= { Your API key }

Here is an example:;_key=yourAPIKey

Adding a monthly electric bill

Energy savings are calculated using the homeowner’s current average monthly electricity bill. By default, the bill is set to a regional average for this address. You can view this average monthly bill by reading the “average_monthly_bill” key in the JSON response.

If you have access to an average monthly bill amount that you would like you use in the calculations, you can specify the monthly bill by adding the url parameter site_overrides[monthly_bill] = 100

The specified monthly bill must be greater than 0, and decimal values will be rounded to the nearest whole dollar, like this: { Search Address } &monthly;_bill= { integer dollars } &api;_key= { Your API key }

Here is an example:;_bill=100&api;_key=yourAPIKey

Building A Solar Application

Geostellar’s API uses a JSON format.

The API is organized according to attributes of the Solar Profile. These attributes will give you everything you need to quickly build a robust Solar Application for the Web or a mobile device.

User Attributes

This is a property owner

get Returns information assigned to a particular user and the fields associated them.


put Updates a user and returns the associated fields.


post Creates a new user and returns the associated fields.


Authentication Attributes

This is for authenticating a user

post Logging in as a user.


delete Logging out as a user.


PV Module Attribute

Adding A Solar Potential Heat Map

Solar Heat Map Example

You can add a Solar Potential Heat Map to an existing Google Map by using the address.region.wms_url from the Solar Estimate JSON results and the following function below


 * // Example Usage
 * var map, rasterOverlay, wmsUrl;
 * // Get Raster Url
 * wmsUrl = solarEstimate.address.region.wms_url;
 * // Create A Google Map
 * map = new google.maps.Map(element, mapOptions)
 * // Add Raster to Google Map
 * rasterOverlay = addRasterOverlayToMap(map, wmsUrl);

var addRasterOverlayToMap;

addRasterOverlayToMap = function(googleMap, rasterUrl) {
  var rasterOverlay, tileHeight, tileWidth;

  if (rasterUrl == null) {
    console.log("The raster url provided is null");

  tileWidth = tileHeight = 256.0;

  rasterOverlay = new google.maps.ImageMapType({
    alt: "Solar Raster",
    name: "Solar Raster",
    isPng: false,
    maxZoom: 20,
    minZoom: 14,
    tileSize: new google.maps.Size(tileWidth, tileHeight),
    getTileUrl: (function(_this) {
      return function(tile, zoom) {
        var lr, projection, ul, zpow;
        projection = googleMap.getProjection();
        zpow = Math.pow(2, zoom);
        ul = projection.fromPointToLatLng(new google.maps.Point(tile.x * tileWidth / zpow, (tile.y + 1) * tileHeight / zpow));
        lr = projection.fromPointToLatLng(new google.maps.Point((tile.x + 1) * tileWidth / zpow, tile.y * tileHeight / zpow));
        return baseUrl + "&BBOX;=" + [ul.lng(),, lr.lng(),].join(',');


  return rasterOverlay;