openapi: 3.0.1
info:
  version: 0.0.1
  title: Zoning API
  description: |-
    # Overview
    
     The Zoning API allows users to retrieve Gridics' lot-specific calibrated zoning information. Depending on the depth of calibration, the zoning information provided by the API reflects base zone regulations, overlays, frontages, and use conditions that may apply within various parts of a municipal or county jurisdiction.
     
     The API is a REST API that responds in JSON format.
    
     <div class="alert alert-info border-0 rounded-sm alert-dismissible" role="alert">
     <strong>Protocol:</strong> HTTPS v1.1<br>
     <strong>Method:</strong> GET<br>
     <strong>URL:</strong> <a href="https://api.gridics.com" target="_blank">https://api.gridics.com</a><br>
     <strong>Example:</strong> <a href="https://api.gridics.com/v1/property-record?state_env=fl&address=444%20BRICKELL%20ST&zipCode=33131" target="_blank">https://api.gridics.com/v1/property-record?state_env=fl&address=444%20BRICKELL%20ST&zipCode=33131</a><br>
     <strong>Response Format:</strong> JSON
     </div>
   
     # User Guide
     ## Get Access
    
     You must request credentials for any applications you develop
     1. Click <a href="https://developer.gridics.com/user/apps" target="_blank">Apps</a> on the portal website.
     2. Click the Add App button. The “Add App” form appears.
     3. Complete the Add App form.
     4. Select the API you want to access.<br>**NOTE:** Apps labeled **DEMO** are approved instantly and are intended for integration testing (300 API call limit).

     5. When you have completed the form, click the Add App button.
    
     ## API Keys

     Every call to the API requires a subscription key. This key needs to be passed through a request header (x-api-key).

     To view your API subscription keys:
     1. From the <a href="https://developer.gridics.com/user/apps" target="_blank">Apps</a> screen, click on the name of your app. The Details screen appears.
     2. If you have access to more than one API, click the name of the relevant API.<br>**NOTE:** The APIs are listed under the “Credentials” section.

     3. Click the **Eyeball** icon next to the *Consumer Key*. The *Consumer Key* appears.
     4. This is the Key you will use when Authenticating your API call. See Authentication below.

     ## Environments
    
     The addressable API base URL/URI environments are:
    
     | Environment | Description |
     | --- | --- |
     | https://api.gridics.com/v1/property-record| Sandbox and production environment |

     ## Rate limits
    
     Rate limits protect the Gridics infrastructure from suspicious requests that exceed defined thresholds.
     
     DEMO APIs are limited to **50 calls per second** and **300 lifetime calls**.
  
     Production APIs are limited to **50 calls per second** and **3000 calls per month**.
  
     Additional rate limits are available and granted according to your specific use case. If you would like additional limits, please <a href="https://developer.gridics.com/contact" target="_blank">Contact Us</a> with more details.

     ## Request Production Access
    
     All production API calls are billed at their respective rates, please test with DEMO APIs before requesting Production Access.
    
     1. Create a new App for production. By doing so, you will get a different API-Key which you can use for your production environment.
     1. To get production access, it is important that both your account and App details are registered correctly.
     1. Subscribe to the API products you want to use in the production environment.
     1. Submit your <a href="https://developer.gridics.com/request-production-access" target="_blank">request for production access</a>. Depending on the API, our team will contact you to discuss the details of your request.
     1. If you desire to license the Services from Gridics for production or other commercial purposes, the parties shall enter into a separate mutually acceptable agreement for such purpose.
     1. Once approved, you are ready to use our API in a live environment.
    
     ## Authentication
     All Gridics APIs use API keys to authenticate requests. You can view and manage your API keys in the Developer Portal under the <a href="https://developer.gridics.com/user/apps" target="_blank">Apps</a> section.

     Your API keys carry usage statistics, so be sure to keep them secure. Don't share your secret API keys in publicly accessible areas such as GitHub, client-side code, and so forth.
    
     Provide your API key as the ***x-api-key*** header.

     You must make all API calls over <a href="https://en.wikipedia.org/wiki/HTTP_Secure" target="_blank">HTTPS</a>. Calls that you make over plain HTTP will fail. API requests without authentication will also fail.

     ```shell
     curl -X GET "https://api.gridics.com/v1/property-record?state_env=fl&address=444%20BRICKELL%20ST&zipCode=33131" \
     -H "x-api-key: YOUR_API_KEY"
     ```
    
     <div class="alert alert-info border-0 rounded-sm alert-dismissible" role="alert">
    Please replace <strong>YOUR_API_KEY</strong>  with the API key found under the Credentials section of your App. 
     </div>
    
     **Invalid API key response**
     ```json
    {
      "status": "ERROR",
      "messages": [
        "Invalid ApiKey"
      ]
    }
     ```

     **Missing API key response**
     ```json
     {
      "status": "ERROR",
      "messages": [
        "Failed to resolve API Key variable request.header.x-api-key"
      ]
    }
     ```

     **Wrong API key response**
     ```json
     {
      "status": "ERROR",
      "messages": [
        "Invalid ApiKey for given resource"
      ]
    }
     ```
    
     # Request Parameters

     The Zoning API allows you to fetch zoning details relevant to parcels in available markets. The fields returned will be determined by which Zoning API you choose to use. 
    
     <div class="alert alert-warning border-0 rounded-sm alert-dismissible" role="alert">
     <span style="color:red;">Required: </span><strong>state_env</strong> + <strong>one other parameter</strong> below are always required.<br>
     <br>
     <strong>Example</strong>: ?state_env=fl&address=123 main street&zipcode=33333<br>
     <br>
     Parameters are case sensitive.
     </div>
    
     | Request Parameters | Details | Example |
     | ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------- |
     | state_env          | <span style="color:red;">*Required: </span><br>**State:** State abbreviation value provided in lowercase format.                                                                                                                                                                              | state_env=fl                                             |
     ||**<span style="color:red;">AND at least one request parameter grouping below is required**</span>||
     | address+zipCode    | **Address + Zip:** Address information should be specified without any units numbers (apt, condo, suite, etc). Zipcode must be provided as a 5 digit value and be a valid USA zipcode.                                                                                                        | address=444 BRICKELL Ave<br>zipCode=33131                |
     | groupId            | **GroupID:** 17 character value generated by Gridics for every parcel.<br>Apply this parameter if you know the **parcel** ID assigned by Gridics.                                                                                                                                             | groupId=296066a795235f372                                |
     | lat+lon            | **Single Map Point (Lat/lon):** Each value needs to be its own parameter and be included with the state_env parameter. To increase the accuracy of results, it is recommended to provide at least 6 digits of precision after a decimal.                                                      | lat=25.769239824444398<br>lon=-80.19044887523829         |
     |                    | **Polygon Search (Area):** The Polygon search uses a different API endpoint and can be found by visiting the Search API documentation.<br><br>A polygon search returns a list of GroupID’s which can then be used with the GroupID request parameter to fetch each parcel's zoning data.      |                                                          |

     # Response Data
    
     Gridics Zoning API returns data according to the API you choose to use. Please visit <a href="https://developer.gridics.com/plans" target="_blank"> API Pricing</a> to view the difference between APIs.

     ## Response Data Summary

     |Summary of fields | Basic | Enhanced | Premium |
     | --- | --- | --- | --- |
     | Address | x | x | x |
     | Zone | x | x | x |
     | Stated Zone Attributes (FAR, Lot Area, Max Height, etc) | x | x | x |
     | Overlays (\*where available) |   | x | x |
     | Uses |   | x | x |
     | Lot Type (Corner, Block, Internal, etc) |   |   | x |
     | Parcel-specific Buildable Capacity (Setbacks, Max Buildable Area, Units Allowed, etc) |   |   | x |
     | Frontages |   |   | x |
     | Geometry |   |   | x |
     |- Base Footprint and Floors |   |   | x |
     |- Base Footprint with Setbacks and Floors with Setbacks |   |   | x |
     |- Building Envelope |   |   | x |

     ## Response Data Details

     <a href="https://docs.google.com/spreadsheets/d/1NvZM3wf42QdXxWjjtVCz_C6f-fq9H9jYF2lANew6LRM/edit?usp=sharing" target="_blank">Data Dictionary</a>
  
     <a href="https://docs.google.com/spreadsheets/d/1jZxbOib7o138fNxFYF7yLEHiUECd-KS5oeG6Smrip-o/edit#gid=0" target="_blank">Response Data with product access</a>
    
     | Object Path                                                | Alias / Title                                | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Field Type       | Imperial Measurement |
     | ---------------------------------------------------------- | -------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------- | -------------------- |
     | Id                                                         | ID                                           | An ID assigned to the calculation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | integer          |                      |
     | GroupId                                                    | GroupID                                      | Gridics Unique identifier that is focused on the parcel shape, rather than the APN or Parcel ID. More releveant when looking at Condo's that all have the same parcel shape but different property attributes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | string           |                      |
     | Address                                                    | Address                                      | Street address                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | string           |                      |
     | State                                                      | City                                         | Name of the city                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | string           |                      |
     | City                                                       | State                                        | 2 letter state abbreviation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | string           |                      |
     | ZipCode                                                    | ZipCode                                      | 5 character zip code                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | string           |                      |
     | FolioNumber                                                | Parcel ID                                    | Assessors Parcel Number (APN), Folio, or source assigned ID                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | string           |                      |
     | LotType                                                    | Lot Type                                     | \-1 = Multiple. Scenarios where a single parcel may have multiple lot types.<br>0 = None. Reserved for cases when Lot type is not calculated for some reason<br>1 = Internal. Only has 1 accessible public street frontage - primary<br>2 = Corner. Has 2 or more intersecting accessible public street frontages - primary and secondary<br>3 = Through. Has 2 or more non-intersecting accessible public street frontages - primary and secondary. One exception is if one of the narrow frontages is less than 9 feet, that is an easement and is not really a valid frontage<br>4 = Flag. Has 1 public street frontage with narrow access and the main body of the lot is surrounded by abutting lots<br>5 = Block. All frontages are accessible public street frontages<br>6 = Locked. Has no accessible public street frontage                                                                                    | integer          |                      |
     | updatedAt                                                  | Last Updated                                 | Time stamp of when the zoning data was last processed against the zoning ordinance                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | string           |                      |
     | Buildings[\*].Views.ZA.lot                                 | (Geometry)                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | geoJSON          |                      |
     | Buildings[\*].Views.ZA.floorsArrays.all                    | (Geometry)                                   | Base Footprint and Floors                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | array of objects |                      |
     | Buildings[\*].Views.ZA.floorsArrays.setbacks               | (Geometry)                                   | Base Footprint with Setbacks and Floors with Setbacks                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | array of objects |                      |
     | Buildings[\*].GeoJSONViews                                 | (Geometry)                                   | There are multiple "Features" in this section. There is the "Property Record Lot" and "Buildings".<br>For Buildings, there are "green", "grey" and "blue".<br>\- Green is the max envelope<br>\- Blue is the envelope according to setbacks ("Green" building can be placed anywhere within the "blue" space)<br>\- Grey are the floorlines for the 3D massing.<br>The "green" and "blue" should be extruded using "$.data[\*].Buildings[\*].GeoJSONViews.ZA.features[\*].properties.height" values. Height is measured in meters.                                                                                                                                                                                                                                                                                                                                                                                      | object           |                      |
     | Buildings[\*].Overlays[\*].Id                              | Overlay ID                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | integer          |                      |
     | Buildings[\*].Overlays[\*].Name                            | Overlay Name                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | string           |                      |
     | Buildings[\*].Overlays[\*].Description                     | Overlay Description                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | string           |                      |
     | Buildings[\*].Overlays[\*].CalibrationType                 | Overlay Type                                 | Identifies the type of overlay<br>1 - Overlay<br>4 - Informational Overlay<br>\- Overlays define a modification to the underlaying zoning regulations that is geographically specific or based on a specific condition. Overlays are typically modifications to the underlying zoning districts.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | integer          |                      |
     | Buildings[\*].Overlays[\*].GridicsId                       |                                              | Internal Gridics ID that references the GIS shape file stored on Gridics platform                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | string           |                      |
     | Buildings[\*].Overlays[\*].Attributes[\*].Id               | Overlay Attribute ID                         | Attribute ID<br>\- If Attributes are present then an array of attributes will be added to the Overlay object. If there are no attributes then the array will be empty.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | integer          |                      |
     | Buildings[\*].Overlays[\*].Attributes[\*].AttributeType    | Overlay Attribute Type                       | 0 - Link<br>1 - Comment<br>2 - Assumption                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | integer          |                      |
     | Buildings[\*].Overlays[\*].Attributes[\*].AttributeValue   | Overlay Attribute                            | This can be simple text or HTML                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | string           |                      |
     | Buildings[\*].Overlays[\*].Attributes[\*].Description      | Overlay Attribute Description                | Simple text                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | string           |                      |
     | Buildings[\*].Overlays[\*].Attributes[\*].IsEnabled        |                                              | TRUE/FALSE                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | boolean          |                      |
     | Buildings[\*].Uses                                         | Allowed Uses                                 | Allowed Uses                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | array of objects |                      |
     | Buildings[\*].Envelope.AreaAllowedByFloorplate             | Form Maximum Buildable Area                  | Maximum buildable based on massing.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | integer          | ft2                  |
     | Buildings[\*].Envelope.DensityNet                          | Residential Density                          | Maximum residential density applicable for this parcel. This value regulates how many residential units can be built within an acre (43,560 sqft), and is represented as dwelling units per acre (du/acre).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | integer          | du/acre              |
     | Buildings[\*].Envelope.DensityUnits                        | Maximum Residential Units                    | Maximum amount of residential units allowed (this value might not be derived only from density).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | integer          | units                |
     | Buildings[\*].Envelope.FloorAreaRatio                      | Floor Area Ratio                             | Floor Area Ratio (FAR) is a factor of the relation of building area to the parcel lot area.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | integer          |                      |
     | Buildings[\*].Envelope.FloorAreaRatioCapacity              | Floor Area Ratio Maximum Buildable Area      | Maximum buildable based on floor area ratio.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | integer          | ft2                  |
     | Buildings[\*].Envelope.LodgingCapacity                     | Maximum Lodging Rooms                        | Maximum amount of lodging rooms allowed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | integer          | rooms                |
     | Buildings[\*].Envelope.LotAreaAcres                        | Simplified Parcel shape Area - Acres         | The calculated parcel area “acres“ (43560sqft = 1 acre) after the parcel shape was simplified.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | float            | acres                |
     | Buildings[\*].Envelope.LotAreaFeet                         | Simplified Parcel Shape Area - Square Feet   | The calculated parcel area “square feet” after the parcel shape was simplified.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | integer          | ft2                  |
     | Buildings[\*].Envelope.LotAreaPR                           | Parcel Area - Tax Record                     | The “recorded” parcel area - as received.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | integer          | ft2                  |
     | Buildings[\*].Envelope.LotAreaFeetGAPI                     | Parcel Area - GIS                            | The calculated parcel area of the parcel shape - as received.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | integer          | ft2                  |
     | Buildings[\*].Envelope.LotCoverage                         | Maximum Building Coverage Percentage         | The maximum percentage area of a parcel that can be occupied by a building or non-permeable area.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | integer          | %                    |
     | Buildings[\*].Envelope.MaxBonusHeightAllowed               | Maximum Bonus Stories (Deprecated)           | The maximum amount of bonus stories allowed. (Miami, FL ONLY)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | integer          | Levels               |
     | Buildings[\*].Envelope.MaxBuildingAreaAllowed              | Maximum Buildable Area                       | The maximum buildable area allowed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | integer          | ft2                  |
     | Buildings[\*].Envelope.MaxBuildingFootprint                | Maximum Building Footprint                   | Maximum building footprint.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | integer          | ft2                  |
     | Buildings[\*].Envelope.MaxCommercialAreaAllowed            | Maximum Commercial Use Allowed               | The maximum area (square feet) of commercial uses allowed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | integer          | ft2                  |
     | Buildings[\*].Envelope.MaxCommercialEstablishedArea        | Maximum Individual Commercial Space          | The maximum area of individual commercial spaces allowed. (Miami, FL ONLY)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | integer          | ft2                  |
     | Buildings[\*].Envelope.MaxCommercialHeightAllowed          | Maximum Commercial Stories                   | The maximum amount of commercial stories allowed starting from the sidewalk.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | integer          | Levels               |
     | Buildings[\*].Envelope.MaxLotCoverageArea                  | Maximum Building Footprint - From Percentage | Maximum building footprint based on coverage percentage.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | integer          | ft2                  |
     | Buildings[\*].Envelope.MaxOfficeAreaAllowed                | Maximum Office Use Allowed                   | The maximum area (square feet) of office uses allowed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | integer          | ft2                  |
     | Buildings[\*].Envelope.MaxOfficeCommercialAllowed          | Maximum Office/Commercial Uses Allowed       | The maximum area of office and commercial uses (combined) allowed. (Miami, FL ONLY)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | integer          | ft2                  |
     | Buildings[\*].Envelope.MaxOfficeHeightAllowed              | Maximum Office Stories                       | The maximum amount of office stories allowed starting from the sidewalk.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | integer          | Levels               |
     | Buildings[\*].Envelope.MaxTowersNumber                     | Maximum Tower Stories                        | The maximum amount of tower stories allowed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | integer          | Levels               |
     | Buildings[\*].Envelope.MinOpenSpace                        | Minimum Open Space Percentage                | Minimum open space percentage of parcel area, this area should be permeable without any building or structure above.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | integer          | %                    |
     | Buildings[\*].Envelope.MinOpenSpaceSquareFeet              | Minimum Open Space                           | The calculated area of minimum open space to be retained.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | integer          | ft2                  |
     | Buildings[\*].Envelope.PodiumArea                          | Main Structure Area (Form)                   | The maximum form area of the main structure, based on massing (Form).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | integer          | ft2                  |
     | Buildings[\*].Envelope.PrincipalMaxHeight                  | Maximum Podium Stories                       | The maximum amount of levels/stories for the podium portion of the building.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | integer          | ft2                  |
     | Buildings[\*].Envelope.PrincipalMinHeight                  | Minimum Podium Stories Required              | Minimum number of stories/levels required.<br>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | integer          | ft2                  |
     | Buildings[\*].Envelope.PrincipalPenthouseHeight            | Maximum Penthouse Height                     | The maximum height of the Penthouse portion of the building; represented in feet.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | integer          | ft                   |
     | Buildings[\*].Envelope.PrincipalTowerHeight                | Maximum Tower Height                         | The maximum height of the Tower portion of the building; represented in feet.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | integer          | ft                   |
     | Buildings[\*].Envelope.SecondLayerDimension                | Liner Building Minimum Depth                 | The minimum depth required for liner buildings; represented in feet.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | integer          | ft                   |
     | Buildings[\*].Envelope.TotalBuidingHeight                  | Maximum Building Height                      | The maximum building height allowed; represented in feet (combining Podium, Towers or Penthouses).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | integer          | Levels               |
     | Buildings[\*].Envelope.TowerArea                           | Maximum Tower Area                           | The maximum Tower(s) area.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | integer          | ft2                  |
     | Buildings[\*].Envelope.TowerBonusMaxHeight                 | Maximum Bonus Stories                        | The maximum number of bonus stories allowed. (Miami, FL ONLY)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | integer          | Levels               |
     | Buildings[\*].Envelope.TowerMaxArea                        | Maximum Tower Footprint                      | The maximum individual tower footprint allowed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | integer          | ft2                  |
     | Buildings[\*].Envelope.TowerMaxAreaActual                  | Maximum Tower Footprint Possible             | The maximum possible tower footprint, based on massing (Form).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | integer          | ft2                  |
     | Buildings[\*].Envelope.LodgingCapacityCalculated           | Maximum Lodging Rooms Allowed                | The maximum amount of lodging (Hotel) rooms allowed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | integer          | rooms                |
     | Buildings[\*].Envelope.MaximumResidentialBuildableArea     | Maximum Residential Uses Allowed             | The maximum area (square feet) of residential uses allowed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | integer          | ft2                  |
     | Buildings[\*].Envelope.MaximumLodgingBuildableArea         | Maximum Lodging Uses Allowed                 | The maximum area (square feet) of lodging uses allowed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | integer          | ft2                  |
     | Buildings[\*].Envelope.EffectivePFrontSetbackPrincipal     | Minimum Podium Primary Front Setback         | The minimum podium or base building primary front setback required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | array of integer | ft                   |
     | Buildings[\*].Envelope.EffectivePFrontSetbackSecondary     | Minimum Podium Secondary Front Setback       | The minimum podium or base building secondary front setback required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | array of integer | ft                   |
     | Buildings[\*].Envelope.EffectivePRearSetback               | Minimum Podium Rear Setback                  | The minimum podium or base building rear setback required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | array of integer | ft                   |
     | Buildings[\*].Envelope.EffectivePSideSetback               | Minimum Podium Side Setback                  | The minimum podium or base building side setback required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | array of integer | ft                   |
     | Buildings[\*].Envelope.EffectivePWaterSetback              | Minimum Podium Waterfront Setback            | The minimum podium or base building waterfront setback required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | array of integer | ft                   |
     | Buildings[\*].Envelope.EffectiveTFrontSetbackPrincipal     | Minimum Tower Primary Front Setback          | The minimum tower building portion primary front setback required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | array of integer | ft                   |
     | Buildings[\*].Envelope.EffectiveTFrontSetbackSecondary     | Minimum Tower Secondary Front Setback        | The minimum tower building portion secondary front setback required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | array of integer | ft                   |
     | Buildings[\*].Envelope.EffectiveTRearSetback               | Minimum Tower Rear Setback                   | The minimum tower building portion rear setback required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | array of integer | ft                   |
     | Buildings[\*].Envelope.EffectiveTSideSetback               | Minimum Tower Side Setback                   | The minimum tower building portion side setback required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | array of integer | ft                   |
     | Buildings[\*].Envelope.EffectiveTWaterSetback              | Minimum Tower Waterfront Setback             | The minimum tower building portion waterfront setback required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | array of integer | ft                   |
     | Buildings[\*].Envelope.EffectivePeFrontSetbackPrincipal    | Minimum Penthouse Primary Front Setback      | The minimum penthouse building portion primary front setback required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | array of integer | ft                   |
     | Buildings[\*].Envelope.EffectivePeFrontSetbackSecondary    | Minimum Penthouse Secondary Front Setback    | The minimum penthouse building portion secondary front setback required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | array of integer | ft                   |
     | Buildings[\*].Envelope.EffectivePeRearSetback              | Minimum Penthouse Rear Setback               | The minimum penthouse building portion rear setback required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | array of integer | ft                   |
     | Buildings[\*].Envelope.EffectivePeSideSetback              | Minimum Penthouse Side Setback               | The minimum penthouse building portion side setback required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | array of integer | ft                   |
     | Buildings[\*].Envelope.MaxIndustrialAreaAllowed            | Maximum Industrial Uses Allowed              | The maximum area (square feet) of Industrial uses allowed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | integer          | ft2                  |
     | Buildings[\*].Envelope.MaxCivicAreaAllowed                 | Maximum Civic Uses Allowed                   | The maximum area (square feet) of civic uses allowed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | integer          | ft2                  |
     | Buildings[\*].Envelope.MaxCivicSupportAreaAllowed          | Maximum Civic Support Uses Allowed           | The maximum area (square feet) of civic support uses allowed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | integer          | ft2                  |
     | Buildings[\*].Envelope.MaxEducationalAreaAllowed           | Maximum Educational Uses Allowed             | The maximum area (square feet) of educational uses allowed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | integer          | ft2                  |
     | Buildings[\*].Envelope.DensityUL                           | Unlimited Residential Density                | Residential Density is unlimited, this is a true/false field.<br>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | boolean          |                      |
     | Buildings[\*].Envelope.LodgingDensityUL                    | Unlimited Lodging Density                    | Lodging Density is unlimited, this is a true/false field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | boolean          |                      |
     | Buildings[\*].ZoningAllowance.ZoneId                       | Primary Zone                                 | The primary zone label.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | string           |                      |
     | Buildings[\*].ZoningAllowance.SubZoneId                    | Sub Zone                                     | The sub zone label, which is dependent to the primary zone to create a combination.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | string           |                      |
     | Buildings[\*].ZoningAllowance.ZoneTypeId                   | Zone Type                                    | The zone type, which is dependent to the primary zone and also to the sub zone, and they create combinations.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | string           |                      |
     | Buildings[\*].ZoningAllowance.BuildingTypologyId           | Building Typology                            | This id represents a unique Gridics typology utilized in the calculations for this record.<br>A typology is a specific development type allowed within the zoning district, and a district may have multiple typologies allowed. This specific id represents the typology used for the calculations of this record (default typology).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | string           |                      |
     | Buildings[\*].ZoningAllowance.ZoningRegulationName         | Zone Regulation Name                         | This is the name of the Zone Regulation which Gridics used to determine the zoning rules to apply.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | varchar (80)     |                      |
     | Buildings[\*].ZoningAllowance.ZoneCombinationName          | Zone                                         | This is the full Zone combination where we combine Primary Zone, Sub Zone and Zone Type to make it easier to understand the Zone as users would read it. For instance, in Miami, FL a T6-8-O is made up from Primary Zone=T6, Sub zone=8, and Zone Type=Open. People that understand zoning in Miami would know the zone as "T6-8-O"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | string           |                      |
     | Buildings[\*].CalibrationGeneral.PFrontSetbackPrincipalMax | Maximum Principal Frontage Setback (Podium)  | Maximum setback dimension for the principal frontage.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | full integer     | ft                   |
     | Buildings[\*].CalibrationGeneral.PFrontSetbackSecondaryMax | Maximum Secondary Frontage Setback (Podium)  | Maximum setback dimension for the secondary frontage.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | full integer     | ft                   |
     | Buildings[\*].CalibrationGeneral.PSideSetbackMax           | Maximum Side Setback (Podium)                | Maximum setback dimension for the sides.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | full integer     | ft                   |
     | Buildings[\*].CalibrationGeneral.PRearSetbackMax           | Maximum Rear Setback (Podium)                | Maximum setback dimension for the rear.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | full integer     | ft                   |
     | Buildings[\*].Frontages[\*].Label                          | Polygon segment Label                        | The internal label for a specific segment of the polygon.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | string           |                      |
     | Buildings[\*].Frontages[\*].FrontageType                   | Frontage Types                               | 1 - Primary Frontage, 2- Secondary Frontage                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | integer          |                      |
     | Buildings[\*].Frontages[\*].Setback                        | Building setback for specific frontage       | The minimum setback required for the specific segment of the polygon.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | number           |                      |
     | Buildings[\*].Frontages[\*].MinThoroughfareWidth           | Right-of-Way width                           | Applicable to primary and secondary frontages, is the width of the right-of-way, or the distance between the specific segment of the polygon and another property across the street.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | number           |                      |
     | Buildings[\*].Frontages[\*].SegmentsLengths                | Frontage dimension                           | The dimension (in feet) of the specific segment of the polygon.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | array of number  |                      |
     | Buildings[\*].UsesStatistic                                | Allowed Use Statistics                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | object           |                      |
     | CalculationStatus                                          | Calculation Status                           | Shows the Calculation status of each Property Record for the selected Zoning Code Version. It is calculated as Status which most often occurs for buildings related to this Property Record and Zoning Code Version.<br>Values:<br>0 - NONE - not yet calculated<br>1 - OK - has calculation result<br>2 - EMPTY_RESPONSE - project was not calculated because the "Zoning Service" returned an empty response or error<br>3 - NO_BUILDINGS - project was calculated but does not contain developments and/or buildings<br>4 - TIMEOUT - calculations took too long (more that 1 minute)<br>5 - ERROR - Service returns an unhandled error with status 500<br>6 - NOT_SAVED - data was not saved because of an incorrect structure or data type<br>7 - WITH_NOTIFICATIONS - calculation result contains Error Notifications<br>8 - INCORRECT_PARAMETERS - calculation failed due to inapplicable calculation parameters | integer          |                      |

     ## Response codes
    
     | Status Code                        | Description                                                                                       |
     | ---------------------------------- | ------------------------------------------------------------------------------------------------- | 
     | 200 - OK                           | Everything worked as expected.                                                                    |
     | 400 - Bad Request                  | The request was unacceptable, often due to missing a required parameter.                          |
     | 401 - Unauthorized                 | No valid API key provided.                                                                        |
     | 404 - Not Found                    | The requested resource doesn't exist.                                                             |
     | 429 - Too Many Requests            | Too many requests hit the API too quickly. We recommend an exponential backoff of your requests.  |
     | 500, 502, 503, 504 - Server Errors | Something went wrong on Gridics API’s end. (These are rare.)                                      |

     # API examples

     # Try It Out
     <div class="auth-panel"><div class="clearfix"></div></div>

servers:
  - url: https://api.gridics.com/v1
    description: Production server


components:
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
security:
  - ApiKeyAuth: []

paths:
  /property-record:
    get:
      summary: Get a property by address
      responses:
        '200':
          description: Successful response
      security:
        - ApiKeyAuth: [ ]
      parameters:
        - name: state_env
          in: query
          description: State abbreviation value provided in lowercase format. This is a requied paramater for all filter options listed below.
          required: true
          schema:
            type: string
            example: "fl"
        - name: address
          in: query
          description: Address information should be specified without any units numbers (apt, condo, suite, etc). Can be used only in combination with state_env and zipCode filters.
          required: false
          schema:
            type: string
            example: "444 BRICKELL AVE"
        - name: zipCode
          in: query
          description: Zipcode must be provided as a 5 digit value and be a valid USA zipcode. Can be used only in combination with state_env and address filters.
          required: false
          schema:
            type: string
            example: "33131"
      x-code-samples:
        - lang: shell
          label: cURL
          source: |
            curl -X GET "https://api.gridics.com/v1/property-record?state_env=fl&address=444 BRICKELL AVE&zipCode=33131" -H "x-api-key: {x-api-key}"
        - lang: php
          label: PHP
          source: |
            <?php

            $ch = curl_init($url);
            curl_setopt_array($ch, array(
              CURLOPT_URL => 'https://api.gridics.com/v1/property-record?state_env=fl&address=444 BRICKELL AVE&zipCode=33131',
              CURLOPT_RETURNTRANSFER => true,
              CURLOPT_ENCODING => '',
              CURLOPT_MAXREDIRS => 10,
              CURLOPT_TIMEOUT => 0,
              CURLOPT_FOLLOWLOCATION => false,
              CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
              CURLOPT_CUSTOMREQUEST => 'GET',
              CURLOPT_HTTPHEADER => array(
              'x-api-key: {{x-api-key}}'
              ),
            ));

            $response = curl_exec($ch);

            if(curl_errno($ch)){
              echo 'Curl error: ' . curl_error($ch);
            }

            curl_close($ch);

            echo $response;
        - lang: go
          label: Go
          source: |
            package main

            import (
              "fmt"
              "net/http"
              "io/ioutil"
            )

            func main() {

              url := "https://api.gridics.com/v1/property-record?state_env=fl&address=444 BRICKELL AVE&zipCode=33131"
              method := "GET"

              client := &http.Client {
              }
              req, err := http.NewRequest(method, url, nil)

              if err != nil {
                fmt.Println(err)
                return
              }
              req.Header.Add("x-api-key", "{x-api-key}")

              res, err := client.Do(req)
              if err != nil {
                fmt.Println(err)
                return
              }
              defer res.Body.Close()

              body, err := ioutil.ReadAll(res.Body)
              if err != nil {
                fmt.Println(err)
                return
              }
              fmt.Println(string(body))
            }
        - lang: c_
          label: C#
          source: |
            var client = new HttpClient(new HttpClientHandler
            {
              AllowAutoRedirect = false,
            });
            var request = new HttpRequestMessage(HttpMethod.Get, "https://api.gridics.com/v1/property-record?state_env=fl&address=444 BRICKELL AVE&zipCode=33131");
            request.Headers.Add("x-api-key", "{x-api-key}");
            var response = await client.SendAsync(request);
            response.EnsureSuccessStatusCode();
            Console.WriteLine(await response.Content.ReadAsStringAsync());
        - lang: java
          label: Java
          source: |
            OkHttpClient client = new OkHttpClient().newBuilder()
              .build();
            MediaType mediaType = MediaType.parse("text/plain");
            RequestBody body = RequestBody.create(mediaType, "");
            Request request = new Request.Builder()
              .url("https://api.gridics.com/v1/property-record?state_env=fl&address=444 BRICKELL AVE&zipCode=33131")
              .method("GET", body)
              .addHeader("x-api-key", "{x-api-key}")
              .build();
            Response response = client.newCall(request).execute();
        - lang: python
          label: Python
          source: |
            import http.client

            conn = http.client.HTTPSConnection("api.gridics.com")
            payload = ''
            headers = {
              'x-api-key': '{x-api-key}'
            }
            conn.request("GET", "/v1/property-record?state_env=fl&address=444 BRICKELL AVE&zipCode=33131", payload, headers)
            res = conn.getresponse()
            data = res.read()
            print(data.decode("utf-8"))
        - lang: ruby
          label: Ruby
          source: |
            require "uri"
            require "net/http"

            url = URI("https://api.gridics.com/v1/property-record?state_env=fl&address=444 BRICKELL AVE&zipCode=33131")

            https = Net::HTTP.new(url.host, url.port)
            https.use_ssl = true

            request = Net::HTTP::Get.new(url)
            request["x-api-key"] = "{x-api-key}"

            response = https.request(request)
            puts response.read_body
        - lang: node_js
          label: Node.js
          source: |
            const axios = require('axios');

            let config = {
              method: 'get',
              maxBodyLength: Infinity,
              url: 'https://api.gridics.com/v1/property-record?state_env=fl&address=444 BRICKELL AVE&zipCode=33131',
              headers: {
                'x-api-key': '{x-api-key}'
              }
            };

            axios.request(config)
            .then((response) => {
              console.log(JSON.stringify(response.data));
            })
            .catch((error) => {
              console.log(error);
            });
