Rebase Platform

https://docs.rebase.energy
Admin
Rebase Platform is a cloud service enabling energy engineers and data scientists to create, deploy,...
Tokens:48,305
Snippets:90
Trust Score:7.1
Update:1 year ago
Show doc for...
Tokens:
Raw
### Train ML Model using Rebase Energy API

Source: https://docs.rebase.energy/api-guides/quickstart

Initiates the training process for ML models by sending a POST request to the Rebase Energy API. Requires site IDs and training data splits. The response confirms if the training has started.

```Python
import requests

# Assume headers are already defined, e.g., with authentication tokens
# headers = {"Authorization": "Bearer YOUR_API_KEY"}

url = "https://api.rebase.energy/platform/v2/sites/models/train"
payload = {
    "site_ids": ["a923653c-26f1-1b29-955d-ffde5d182276"],
    "splits": [
        {
            "end_date": "2023-08-01T00:00Z",
            "start_date": "2023-01-01T00:00Z"
        },
        {
            "end_date": "2024-01-01T00:00Z",
            "start_date": "2023-10-01T00:00Z"
        }
    ]
}

response = requests.post(url, json=payload, headers=headers)
response.raise_for_status() # Raise an exception for bad status codes
response_data = response.json()
print(response_data)

```

--------------------------------

### Create New Solar Site with Rebase API

Source: https://docs.rebase.energy/api-guides/quickstart

Demonstrates how to create a new solar site using the Rebase API. Requires an API key and provides site parameters like location, capacity, and settings. Returns the site ID upon successful creation.

```python
import requests
api_key = "Your API key" # Set your API key
payload = {
	"type": "solar",
	"name": "New solar site",
	"latitude": 52.5,
	"longitude": 13.4,
	"settings": {
		"model_resolution": "1h",
		"usePhysicalModels": True,
		"trainNearTermModels": False,
		"trainLongTermModels": False
	},
	"assets": [
		{
			"azimuth": 180,
			"tilt": 30,
			"capacity": 1000,
			"install_date": "2024-01-01"
		}
	]
}
url = "https://api.rebase.energy/platform/v2/sites"
headers = {"Authorization": api_key, "Content-Type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
response.raise_for_status()
response = response.json()

# Response example:
# {
#     "site_id": "a923653c-26f1-1b29-955d-ffde5d182276"
# }
```

--------------------------------

### List Sites (cURL Example)

Source: https://docs.rebase.energy/api-reference/site/list-sites

Example cURL command to list all sites associated with the Rebase platform. Requires an API key for authorization.

```bash
curl --request GET \
  --url https://api.rebase.energy/platform/v2/sites \
  --header 'Authorization: <api-key>'
```

--------------------------------

### Get Site Actuals (cURL Example)

Source: https://docs.rebase.energy/api-reference/site/get-site-actuals

Example using cURL to fetch actual data for a specific site. This demonstrates the HTTP GET request, URL structure, and required authorization header.

```shell
curl --request GET \
  --url https://api.rebase.energy/platform/v2/sites/{site_id}/actual \
  --header 'Authorization: <api-key>'
```

--------------------------------

### API Response Example: Site Creation

Source: https://docs.rebase.energy/api-guides/create-site-wind

Example of a successful API response after creating a new wind site, containing the unique identifier for the created site.

```json
{
    "site_id": "dfd365tc-2644-3627-905a-ghjjd182u78"
}
```

--------------------------------

### Upload Site Actuals Example (cURL)

Source: https://docs.rebase.energy/api-reference/site/upload-site-actuals

Example of how to upload actual energy production or consumption data for a site using cURL. This data is crucial for model training and forecast accuracy evaluation.

```cURL
curl --request POST \
  --url https://api.rebase.energy/platform/v2/sites/{site_id}/actual \
  --header 'Authorization: <api-key>' \
  --header 'Content-Type: application/json' \
  --data '{ \
  "type": "power", \
  "data": [ \
    { \
      "valid_time": "2024-01-01T00:00:00Z", \
      "value": 6000 \
    } \
  ] \
}'
```

--------------------------------

### Update Site Example (cURL)

Source: https://docs.rebase.energy/api-reference/site/update-site

Example of how to update a site's information using a cURL command. This demonstrates the HTTP method, URL, headers, and a sample JSON payload for the request.

```curl
curl --request PUT \
  --url https://api.rebase.energy/platform/v2/sites/{site_id} \
  --header 'Authorization: <api-key>' \
  --header 'Content-Type: application/json' \
  --data '{ \
  "name": "My site", \
  "latitude": 52.5, \
  "longitude": 13.4, \
  "settings": { \
    "model_resolution": "1h", \
    "additional_points": [ \
      { \
        "name": "Berlin", \
        "latitude": 52.5, \
        "longitude": 13.4 \
      } \
    ], \
    "trainLongTermModels": true, \
    "trainNearTermModels": true, \
    "usePhysicalModels": true, \
    "weather_models": [ \
      "<string>" \
    ], \
    "create_params": {} \
  }, \
  "type": "solar", \
  "assets": [ \
    { \
      "azimuth": 180, \
      "tilt": 30, \
      "capacity": 1000, \
      "install_date": "2020-01-01" \
    } \
  ] \
}'
```

--------------------------------

### API Response Example for Site Deletion

Source: https://docs.rebase.energy/api-guides/delete-site

An example of the JSON response received from the Rebase Platform API upon successful deletion of a site.

```json
{
    "message": "Site deleted successfully"
}
```

--------------------------------

### Upload Generation Data to Rebase API

Source: https://docs.rebase.energy/api-guides/quickstart

Shows how to upload measured power generation data for a specific site to the Rebase API. Data should ideally cover at least one year with hourly or more frequent resolution for better ML model performance. Returns a success message.

```python
site_id = "a923653c-26f1-1b29-955d-ffde5d182276" # This is the ID of the new site
payload = {"data": [
        {
            "valid_time": "2024-01-01T12:00:00Z",
            "value": 300.5
        },
		{
            "valid_time": "2024-01-01T13:00:00Z",
            "value": 320.2
        }
    ]
}
url = f"https://api.rebase.energy/platform/v2/sites/{site_id}/actual"
response = requests.post(url, json=payload, headers=headers)
response.raise_for_status()
response = response.json()

# Response example:
# {
#     "message": "Actuals uploaded successfully"
# }
```

--------------------------------

### List Sites (JSON Response Example)

Source: https://docs.rebase.energy/api-reference/site/list-sites

Example JSON response structure for the List Sites API endpoint, detailing site metadata such as ID, name, location, capacity, and settings.

```json
[
  {
    "id": "48302759-0371-4d54-9ba1-506708b576fe",
    "site_id": "48302759-0371-4d54-9ba1-506708b576fe",
    "name": "My site",
    "latitude": 52.5,
    "longitude": 13.4,
    "capacity_kw_array": [
      {}
    ],
    "creation_timestamp_utc": "2023-11-07T05:31:56Z",
    "settings": {
      "model_resolution": "1h",
      "additional_points": [],
      "trainLongTermModels": true,
      "trainNearTermModels": true,
      "usePhysicalModels": true,
      "weather_models": [],
      "create_params": {}
    },
    "type": "solar",
    "assets": [
      {
        "azimuth": 180,
        "tilt": 30,
        "capacity": 1000,
        "install_date": "2020-01-01"
      }
    ]
  }
]
```

--------------------------------

### API Authorization Header Example

Source: https://docs.rebase.energy/api-guides/authorization

Demonstrates how to set up the necessary HTTP headers for authenticating API requests to the Rebase Platform. It includes the Authorization header with the API key and the Content-Type header.

```python
headers = {
	"Authorization": "Your API Key",
	"Content-Type": "application/json"
}
requests.get(url, headers=headers)
```

--------------------------------

### API Response for Site Update

Source: https://docs.rebase.energy/api-guides/update-site

This is an example of a successful response received after updating a site's information via the Rebase Platform API.

```json
{
    "message": "Site updated successfully"
}

```

--------------------------------

### Get Site Actuals (JSON Response Example)

Source: https://docs.rebase.energy/api-reference/site/get-site-actuals

Example JSON response for the 'Get Site Actuals' API endpoint, showing the structure of 'valid_time' and 'value' arrays.

```json
{
  "valid_time": [
    "2024-01-01T00:00:00Z",
    "2024-01-01T01:00:00Z",
    "2024-01-01T02:00:00Z",
    "2024-01-01T03:00:00Z",
    "2024-01-01T04:00:00Z",
    "2024-01-01T05:00:00Z",
    "2024-01-01T06:00:00Z",
    "2024-01-01T07:00:00Z",
    "2024-01-01T08:00:00Z",
    "2024-01-01T09:00:00Z"
  ],
  "value": [
    6000,
    6000,
    6000,
    6000,
    6000,
    6000,
    6000,
    6000,
    6000,
    6000
  ]
}
```

--------------------------------

### Rebase Platform Site Configuration - General

Source: https://docs.rebase.energy/dashboard/create-site-ui

Outlines the general steps and site types available for creating a new site on the Rebase Platform via the dashboard.

```APIDOC
Site Creation Process:

Step 1: Add Site
  - Action: Click 'Add site' button (top left corner).

Step 2: Choose Site Type
  - Supported Types:
    - Solar Power
    - Wind Power
    - Electricity Demand

Step 3: Configure Site
  - Configuration varies based on the chosen site type.

Step 4: Upload Power Measurements
  - (Details on upload process not provided in this text).
```

--------------------------------

### Python: Get Historical Forecast

Source: https://docs.rebase.energy/api-guides/get-forecast-historical

Example Python code using the `requests` library to fetch historical forecast data for a specific site. It demonstrates setting up the API key, site ID, date parameters, and making a GET request.

```python
import requests

api_key = "Your API key" # Set your API key
site_id = "a923653c-26f1-1b29-955d-ffde5d182276" # Set the site ID
start_date = "2024-06-28 00:00" # Set the start date
end_date = "2024-06-28 01:00" # Set the end date
as_of = "2024-06-27 11:00" # Set the reference time

url = f"https://api.rebase.energy/platform/v2/sites/{site_id}/forecast"
headers = {"Authorization": api_key, "Content-Type": "application/json"}
params={
	'start_date': start_date,
	'end_date': end_date,
	'as_of': as_of
}

response = requests.get(url, headers=headers, params=params)
response.raise_for_status() # Raise an exception for bad status codes
response_data = response.json()

print(response_data)
```

--------------------------------

### Create Solar Site (Python)

Source: https://docs.rebase.energy/api-guides/create-site-solar

Python script demonstrating how to create a single-asset solar site using the Rebase Energy API. It includes setting up the API key, payload, and making a POST request.

```python
import requests

api_key = "Your API key" # Set your API key
payload = {
	"type": "solar",
	"name": "My solar site",
	"latitude": 52.5,
	"longitude": 13.4,
	"settings": {
		"model_resolution": "1h",
		"usePhysicalModels": True,
		"trainNearTermModels": False,
		"trainLongTermModels": False
	},
	"assets": [
		{
			"azimuth": 180,
			"tilt": 30,
			"capacity": 1000,
			"install_date": "2020-01-01"
		}
	]
}

url = "https://api.rebase.energy/platform/v2/sites"
headers = {"Authorization": api_key, "Content-Type": "application/json"}

response = requests.post(url, headers=headers, json=payload)
response.raise_for_status() # Raise an exception for bad status codes
response_data = response.json()

print(response_data)
```

--------------------------------

### Get Site Metadata

Source: https://docs.rebase.energy/api-guides/get-site-info

Fetches metadata for a specific site using its unique ID. This example demonstrates how to make a GET request to the Rebase Energy platform API, requiring an API key and a site ID. It uses the requests library to handle the HTTP call and JSON parsing.

```python
import requests

api_key = "Your API key" # Set your API key
site_id = "a923653c-26f1-1b29-955d-ffde5d182276" # Set the site ID

url = f"https://api.rebase.energy/platform/v2/sites/{site_id}"
headers = {"Authorization": api_key, "Content-Type": "application/json"}

try:
    response = requests.get(url, headers=headers)
    response.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx)
    site_data = response.json()
    print(site_data)
except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")

```

--------------------------------

### Query ML Model Forecast from Rebase Energy API

Source: https://docs.rebase.energy/api-guides/quickstart

Retrieves the latest available forecast data for a specific site using a GET request to the Rebase Energy API. The response contains forecast values along with associated metadata like valid time and model information.

```Python
import requests

# Assume headers and site_id are already defined
# headers = {"Authorization": "Bearer YOUR_API_KEY"}
# site_id = "your_site_id"

url = f"https://api.rebase.energy/platform/v2/sites/{site_id}/forecast"
response = requests.get(url, headers=headers)
response.raise_for_status() # Raise an exception for bad status codes
response_data = response.json()
print(response_data)

```

--------------------------------

### Rebase Energy Platform API: Create Site

Source: https://docs.rebase.energy/api-guides/create-site-load

Documentation for creating a new site (load, solar, etc.) via the Rebase Energy Platform API. This includes the endpoint, method, request body structure, and response.

```APIDOC
POST /platform/v2/sites

Creates a new site on the Rebase Energy platform.

Request Body:
{
  "type": "string" (required) - The type of site (e.g., "load", "solar").
  "name": "string" (required) - The name of the site.
  "latitude": "number" (required) - The latitude coordinate of the site.
  "longitude": "number" (required) - The longitude coordinate of the site.
  "settings": {
    "model_resolution": "string" (optional) - The resolution for models (e.g., "1h", "24h").
    "additional_points": [
      {
        "name": "string" (required) - Name of the additional location.
        "latitude": "number" (required) - Latitude of the additional location.
        "longitude": "number" (required) - Longitude of the additional location.
      }
    ] (optional) - A list of additional geographical points associated with the site.
    "trainNearTermModels": "boolean" (optional) - Whether to train near-term models.
    "trainLongTermModels": "boolean" (optional) - Whether to train long-term models.
  } (optional) - Configuration settings for the site.
}

Response:
{
  "site_id": "string" - The unique identifier of the newly created site.
}

Example Usage:
See Python example for creating a load site with additional points.
```

--------------------------------

### Rebase Energy API Response Structure for Forecast

Source: https://docs.rebase.energy/api-guides/quickstart

Illustrates the structure of the JSON response when querying forecast data. It includes arrays for valid times, forecast values, model names, model versions, and update times.

```JSON
{
  "valid_time": [
    "2024-01-01T00:00:00Z",
    "2024-01-01T01:00:00Z",
    "2024-01-01T02:00:00Z"
  ],
  "forecast": [
    6000,
    6000,
    6000
  ],
  "model_name": [
    "My model",
    "My model",
    "My model"
  ],
  "model_version": [
    1,
    1,
    1
  ],
  "update_time": [
    "2024-01-01T00:00:00Z",
    "2024-01-01T00:00:00Z",
    "2024-01-01T00:00:00Z"
  ]
}
```

--------------------------------

### Rebase API Reference - Site Management

Source: https://docs.rebase.energy/api-guides/set-up-sites

This section consolidates key API endpoints for managing forecast sites within the Rebase Platform. It covers listing sites, creating, updating, and deleting them, along with retrieving site-specific metadata.

```APIDOC
API Endpoint: /sites

GET /sites
  Description: Lists all forecast sites associated with the authenticated user.
  Parameters:
    - None
  Returns:
    - A list of site objects, each containing site details.

POST /sites
  Description: Creates a new forecast site.
  Parameters:
    - site_type: (string, required) Type of the site (e.g., 'wind', 'solar', 'load').
    - name: (string, required) Name of the site.
    - location: (object, required) Geographic coordinates of the site.
      - latitude: (number, required)
      - longitude: (number, required)
    - metadata: (object, optional) Additional site-specific metadata.
  Returns:
    - The newly created site object.

GET /sites/{site_id}
  Description: Retrieves metadata for a specific forecast site.
  Parameters:
    - site_id: (string, required) The unique identifier of the site.
  Returns:
    - The site object with detailed metadata.

PUT /sites/{site_id}
  Description: Updates an existing forecast site.
  Parameters:
    - site_id: (string, required) The unique identifier of the site.
    - Updates can include name, location, metadata, etc.
  Returns:
    - The updated site object.

DELETE /sites/{site_id}
  Description: Deletes a forecast site.
  Parameters:
    - site_id: (string, required) The unique identifier of the site.
  Returns:
    - Confirmation of deletion or an appropriate status code.
```

--------------------------------

### Get Site Forecast API

Source: https://docs.rebase.energy/api-reference/site/get-site-forecast

Retrieves the energy forecast for a specific solar site. If no start date is provided, it defaults to 00:00 UTC of the current day. The response includes valid times, forecast values, model names, model versions, and update times.

```APIDOC
GET /platform/v2/sites/{site_id}/forecast

Description:
  Get the forecast of a site for a given date range. If no start_date is provided, 00:00 UTC of the current day is used.

Parameters:
  site_id (string, required): The unique identifier for the site.
  Authorization (string, header, required): Your API key. This is required to access our API programmatically.

Responses:
  200 OK:
    Content:
      application/json:
        schema:
          type: object
          properties:
            valid_time: { type: array, items: { type: string, format: date-time } }
            forecast: { type: array, items: { type: number } }
            model_name: { type: array, items: { type: string } }
            model_version: { type: array, items: { type: integer } }
            update_time: { type: array, items: { type: string, format: date-time } }
    Example:
      {
        "valid_time": [
          "2024-01-01T00:00:00Z",
          "2024-01-01T01:00:00Z"
        ],
        "forecast": [
          6000,
          6000
        ],
        "model_name": [
          "My model",
          "My model"
        ],
        "model_version": [
          1,
          1
        ],
        "update_time": [
          "2024-01-01T00:00:00Z",
          "2024-01-01T00:00:00Z"
        ]
      }
  400 Bad Request:
    Description: Invalid request parameters or missing authorization.

Example Usage (cURL):
  curl --request GET \
    --url https://api.rebase.energy/platform/v2/sites/{site_id}/forecast \
    --header 'Authorization: <api-key>'
```

--------------------------------

### Create Solar Site API Documentation

Source: https://docs.rebase.energy/api-guides/create-site-solar

Defines the parameters and settings required to create a new solar site via the Rebase Platform API. This includes site identification, location, solar park specifics, and model configuration.

```APIDOC
APIDOC:
  CreateSolarSite(site_data: object)
    Description: Creates a new solar site for forecasting in the Rebase Platform.
    Parameters:
      site_data:
        type: object
        required:
          - type
          - name
          - latitude
          - longitude
          - assets
          - settings
        properties:
          type:
            type: string
            description: Specify the type of the site. For a solar site, it should be 'solar'.
            example: "solar"
          name:
            type: string
            description: A name for the site, used for easy recognition.
            example: "My solar site"
          latitude:
            type: number
            description: The latitude of the site location. Must be between -90 and 90.
            example: 52.5
          longitude:
            type: number
            description: The longitude of the site location. Must be between -180 and 180.
            example: 13.4
          assets:
            type: object
            description: Details specific to the solar park.
            properties:
              capacity:
                type: number
                description: The capacity of the solar park in kilowatts (kW). Must be a positive number.
                example: 1000
              azimuth:
                type: number
                description: The orientation (azimuth) of the PV panels in degrees (0 N, 90 E, 180 S, 270 W). Must be between 0 and 360.
                example: 180
              tilt:
                type: number
                description: The inclination (tilt) of the PV panels in degrees. Must be between 0 and 90.
                example: 180
              install_date:
                type: string
                format: date
                description: The date when the system was installed, in 'YYYY-MM-DD' format.
                example: "2020-01-01"
          settings:
            type: object
            description: Configuration settings for the forecasting models.
            properties:
              model_resolution:
                type: string
                description: How frequently the forecasts will be updated. Accepts '15min', '30min', '1h', or '1d'.
                enum: ["15min", "30min", "1h", "1d"]
              trainLongTermModels:
                type: boolean
                description: Whether to train a model based on typical meteorological year for long-term forecasting.
                example: true
              trainNearTermModels:
                type: boolean
                description: Whether to train a model based on recent power observations for short-term forecasting. Requires real-time power data.
                example: true
              usePhysicalModels:
                type: boolean
                description: Whether to enable physical models. No training data is required for these models.
                example: true
    Returns:
      (Details on return value not provided in source text, typically includes site ID and status)
```

--------------------------------

### Rebase API Reference - Site Management

Source: https://docs.rebase.energy/dashboard/create-site-ui

Provides access to API endpoints for managing sites within the Rebase Platform. This includes listing existing sites and potentially creating new ones via API calls.

```APIDOC
API Reference:
  URL: https://docs.rebase.energy/api-reference/site/list-sites

Endpoint: /sites
  Method: GET
  Description: Retrieves a list of all sites associated with the user's account.
  Parameters:
    - None directly documented for listing.
  Returns:
    - A JSON array of site objects, each containing site details like ID, name, type, and configuration.

Related Endpoints:
  - POST /sites: To create a new site (details not provided in this text).
  - GET /sites/{site_id}: To retrieve details for a specific site.
```

--------------------------------

### Create Multi-Asset Solar Site (Python)

Source: https://docs.rebase.energy/api-guides/create-site-solar

Python script demonstrating how to create a multi-asset solar site using the Rebase Energy API. This example shows how to include multiple solar panel configurations within a single site creation request.

```python
import requests

api_key = "Your API key" # Set your API key
payload = {
	"type": "solar",
	"name": "My solar site",
	"latitude": 52.5,
	"longitude": 13.4,
	"settings": {
		"model_resolution": "1h",
		"usePhysicalModels": True,
		"trainNearTermModels": False,
		"trainLongTermModels": False
	},
	"assets": [
		{
			"azimuth": 180,
			"tilt": 30,
			"capacity": 10,
			"install_date": "2020-01-01"
		},
		{
			"azimuth": 90,
			"tilt": 25,
			"capacity": 5,
			"install_date": "2020-01-01"
		}	
	]
}

url = "https://api.rebase.energy/platform/v2/sites"
headers = {"Authorization": api_key, "Content-Type": "application/json"}

response = requests.post(url, headers=headers, json=payload)
response.raise_for_status() # Raise an exception for bad status codes
response_data = response.json()

print(response_data)
```

--------------------------------

### Create Site API Request (cURL)

Source: https://docs.rebase.energy/api-reference/site/create-site

Demonstrates how to create a new site using the Rebase Platform API via a cURL command. This example includes authentication, content type, and a JSON payload with site details such as name, location, settings, type, and assets.

```bash
curl --request POST \
  --url https://api.rebase.energy/platform/v2/sites \
  --header 'Authorization: <api-key>' \
  --header 'Content-Type: application/json' \
  --data '{
  "name": "My site",
  "latitude": 52.5,
  "longitude": 13.4,
  "settings": {
    "model_resolution": "1h",
    "additional_points": [
      {
        "name": "Berlin",
        "latitude": 52.5,
        "longitude": 13.4
      }
    ],
    "trainLongTermModels": true,
    "trainNearTermModels": true,
    "usePhysicalModels": true,
    "weather_models": [
      "<string>"
    ],
    "create_params": {}
  },
  "type": "solar",
  "assets": [
    {
      "azimuth": 180,
      "tilt": 30,
      "capacity": 1000,
      "install_date": "2020-01-01"
    }
  ]
}'
```

--------------------------------

### Get Model Input API Endpoint

Source: https://docs.rebase.energy/api-reference/model/get-model-input

Retrieves the latest input data for a specified model. This endpoint requires authentication and accepts a model ID as a path parameter.

```APIDOC
GET /platform/v2/models/{model_id}/input

Description:
  Get the latest input data for a model.

Method:
  GET

Endpoint:
  /platform/v2/models/{model_id}/input

Authorization:
  Authorization: string (header, required)
    Your API key. This is required to access our API programatically. You can view your API key in the Rebase dashboard.

Path Parameters:
  model_id: string (required)
    The ID of the model for which to retrieve input data.

Responses:
  200 OK:
    Content-Type: application/json
    Body:
      {
        "dataframe": {},
        "metadata": {}
      }
    - dataframe: object (required)
      Contains the input data.
    - metadata: object (required)
      Contains metadata related to the input data.
  400 Bad Request:
    Indicates an issue with the request, such as an invalid model ID or missing authorization.

Related Endpoints:
  - GET /platform/v2/models/{model_id}/output: Retrieves the output data for a model.
```

```curl
curl --request GET \
  --url https://api.rebase.energy/platform/v2/models/{model_id}/input \
  --header 'Authorization: <api-key>'
```

```json
{
  "dataframe": {},
  "metadata": {}
}
```

--------------------------------

### Create Solar Site API

Source: https://docs.rebase.energy/api-guides/create-site-solar

Documentation for the API endpoint used to create solar sites. It details the request payload structure for site creation, including single or multiple assets, and the expected response format.

```APIDOC
POST /platform/v2/sites

Description:
  Creates a new solar site on the Rebase Energy platform.

Request Body:
  The request body must be a JSON object containing the site's details.

  Parameters:
    type (string): The type of the site, e.g., "solar".
    name (string): The name of the solar site.
    latitude (number): The geographical latitude of the site.
    longitude (number): The geographical longitude of the site.
    settings (object): Configuration settings for the site.
      model_resolution (string): The resolution for models, e.g., "1h".
      usePhysicalModels (boolean): Whether to use physical models.
      trainNearTermModels (boolean): Whether to train near-term models.
      trainLongTermModels (boolean): Whether to train long-term models.
    assets (array): A list of assets associated with the site.
      Each asset object should contain:
        azimuth (number): The azimuth angle of the asset (e.g., solar panel orientation).
        tilt (number): The tilt angle of the asset (e.g., solar panel inclination).
        capacity (number): The capacity of the asset in kW.
        install_date (string): The installation date in YYYY-MM-DD format.

Example Request Payload (Single Asset):
{
  "type": "solar",
  "name": "My solar site",
  "latitude": 52.5,
  "longitude": 13.4,
  "settings": {
    "model_resolution": "1h",
    "usePhysicalModels": true,
    "trainNearTermModels": false,
    "trainLongTermModels": false
  },
  "assets": [
    {
      "azimuth": 180,
      "tilt": 30,
      "capacity": 1000,
      "install_date": "2020-01-01"
    }
  ]
}

Example Request Payload (Multi-Asset):
{
  "type": "solar",
  "name": "My solar site",
  "latitude": 52.5,
  "longitude": 13.4,
  "settings": {
    "model_resolution": "1h",
    "usePhysicalModels": true,
    "trainNearTermModels": false,
    "trainLongTermModels": false
  },
  "assets": [
    {
      "azimuth": 180,
      "tilt": 30,
      "capacity": 10,
      "install_date": "2020-01-01"
    },
    {
      "azimuth": 90,
      "tilt": 25,
      "capacity": 5,
      "install_date": "2020-01-01"
    }
  ]
}

Response:
  On successful creation, the API returns a JSON object containing the ID of the newly created site.

Example Response:
{
  "site_id": "a923653c-26f1-1b29-955d-ffde5d182276"
}
```
Tokens:
Raw