EnAppSys Python Client
The Python library for the EnAppSys platform provides a light-weight, typed Python client to interact with EnAppSys' API services. Additionally, there is an asynchronous client for non-blocking operations.
Project Status
This project is in active development (0.x release series). While the core API structure is expected to remain stable, minor breaking changes may occur between releases.
Installation
Supports Python 3.10+
pip install enappsys[pandas,async]
The extras are optional:
pandasrequired for converting API responses to DataFrames, e.g. viaclient_response.to_df()asyncrequired for using theEnAppSysAsyncasynchronous client.
If you only need the synchronous client and raw responses, install without extras:
pip install enappsys
Configuring credentials
Your EnAppSys username and secret are required to make API requests. You can obtain these as follows:
-
Go to any download page on EnAppSys and click Copy API URL.
-
In the copied URL:
- The value after
user=is your username. - The value after
pass=is your secret (a long numeric string).
- The value after
The client looks for credentials in the following order:
-
Direct arguments when creating the client:
from enappsys import EnAppSys client = EnAppSys( user="example_user", secret="123456789123456789123456789123456789" )
-
Environment variables:
export ENAPPSYS_USER=example_user export ENAPPSYS_SECRET=123456789123456789123456789123456789
-
Credentials file at your home directory, the default location is:
~/.credentials/enappsys.json:{ "user": "example_user", "secret": "123456789123456789123456789123456789" }
You can also save and specify a custom path:
client = EnAppSys(credentials_file="path/to/credentials.json")
Credentials in logs
The platform authenticates with user and pass query parameters, so every
request URL contains them. Creating a client therefore attaches a logging filter
to urllib3.connectionpool and aiohttp.client that replaces the secret with
<redacted>, because those libraries log the request line they send and would
otherwise write it into any log with DEBUG enabled.
The username and the rest of the URL are left alone, so the logs stay useful and a request can still be traced back to an account:
https://app.enappsys.com:443 "GET /csvapi?type=ENTSOE_DAY_AHEAD_PRICES&res=qh&user=your-username&pass=<redacted> HTTP/1.1" 200 None
Usage
The EnAppSys client provides several download interfaces, depending on your user permissions.
Bulk API
The Bulk API is a subscription service that allows you to retrieve time series data. A data type represents a group of related series, and each individual series within that group is referred to as an entity.
The web interface for browsing available data types and entities is available at: https://app.enappsys.com/#dataservicecsv
Retrieve the DA_PRICE and DA_VOLUME entities belonging to EPEX_HR_AUCTION_RESULTS_DE and convert them to a pandas DataFrame. When converting to a DataFrame, you can also rename the columns:
day_ahead = client.bulk.get(
"csv",
data_type="EPEX_HR_AUCTION_RESULTS_DE",
entities=["DA_PRICE", "DA_VOLUME"],
start_dt="2025-01-01T00:00",
end_dt="2025-01-02T00:00",
resolution="qh",
time_zone="CET",
)
df = day_ahead.to_df(rename_columns=["price", "volume"])
To retrieve all entities for a given data_type, omit the entities argument or pass None:
day_ahead_all = client.bulk.get(
"csv",
data_type="EPEX_HR_AUCTION_RESULTS_DE",
start_dt="2025-01-01T00:00",
end_dt="2025-01-02T00:00",
resolution="qh",
time_zone="CET",
)
df_all = day_ahead_all.to_df()
The Bulk API supports multiple response formats:
"csv""json""json_map""xml"
The JSON-based formats optionally include metadata fields:
timestamp: Indicates when the data was first entered into the database or created as a forecast (UTC).last_updated: Indicates the last time the data was updated in the database (UTC).
These fields can be included when converting the response to a DataFrame:
data = client.bulk.get(
"json",
data_type="EPEX_HR_AUCTION_RESULTS_DE",
start_dt="2025-01-01T00:00",
end_dt="2025-01-02T00:00",
resolution="qh",
time_zone="CET",
)
df = data.to_df(timestamp=True, last_updated=True)
Units
Series with a unit assigned have a base unit, shown in the chart info tooltip on
the platform. They are returned in that unit unless you pass units, in which
case the platform converts them. For example, API2 coal is quoted in USD/teCOAL:
coal = client.bulk.get(
"csv",
data_type="spectron_closing_prices_coal_api2_cif_ara_mid",
entities=["PREVAILING"],
start_dt="2026-09-01T00:00",
end_dt="2026-09-02T00:00",
resolution="daily",
time_zone="CET",
units="EUR/MWh", # or units="USD/teCOAL" (the base unit, same as omitting it)
)
df = coal.to_df(unit_in_columns=True) # column "PREVAILING (EUR/MWh)"
An unknown unit name fails with HTTP 400. A known unit that the series cannot be
converted to does not raise or warn: the data comes back in its base unit, but
labelled with the unit you asked for (EUR/MWh gas requested as EUR/te returns
the EUR/MWh values labelled EUR/te).
A mapping of datatype-entities to their base units is currently not available through the API. You can read the base unit in either of these ways:
- Charts: open the chart information, select the series in the dropdown and read its Base Unit.
- Bulk API: download a short range without
units. In CSV the unit is in the Units column (to_df(unit_in_columns=True)adds it to the column names). In JSON it is undermetadata.dataTypes["<DATA_TYPE>.<ENTITY>"].unit, e.g."unit": "USD/teCOAL"forSPECTRON_CLOSING_PRICES_COAL_API2_CIF_ARA_MID.PREVAILING.
Large requests
A wide date range can be split into several requests and stitched back together, so a long history arrives as one result. It is off unless you ask for it:
data = client.bulk.get(
"csv",
data_type="ENTSOE_AGGREGATED_GENERATION_PER_TYPE",
entities=["DE.GERMANY_SOLAR"],
start_dt="2023-01-01T00:00",
end_dt="2026-01-01T00:00",
resolution="qh",
time_zone="UTC",
chunk_rows=True,
)
chunk_rows takes three forms:
| value | effect |
|---|---|
omitted, None or False |
one request |
True |
split at CHUNK_ROWS (5,000) |
an int |
split at that many rows |
True is the one to reach for first. Name a number instead when you want
fewer, larger requests, or more, smaller ones. Either way the count is cells
rather than rows, since requesting two entities returns two series worth of
data. On the asynchronous client the chunks are fetched concurrently.
Worth knowing before you opt in: several requests are not one request. For example, if the data is updated while the chunks are in flight, the later ones return the new values and the earlier ones the old, and a stitched result does not show that it happened. Leave it off where that matters.
Chart API
The Chart API extracts data directly from charts available on the EnAppSys platform.
Each chart is identified by a code, which can be found in the page URL. For example:
https://app.enappsys.com/#de/elec/pricing/daprices/chart
The chart code is the part between # and /chart, in this case:
de/elec/pricing/daprices
Example usage:
day_ahead_chart = client.chart.get(
"csv",
code="de/elec/pricing/daprices",
start_dt="2025-01-01T00:00",
end_dt="2025-01-02T00:00",
resolution="qh",
time_zone="CET",
)
df_day_ahead_chart = day_ahead_chart.to_df()
Some charts support the optional enable_settlement_period flag:
settlement_chart = client.chart.get(
"csv",
code="gb/elec/pricing/daprices",
resolution="hh",
start_dt="2026-07-13T10:49",
end_dt="2026-07-13T18:49",
time_zone="WET",
currency="GBP",
enable_settlement_period=True,
)
df_settlement = settlement_chart.to_df()
Some charts also support alternative time window modes via time_display:
rolling_chart = client.chart.get(
"csv",
code="gb/elec/pricing/daprice/ensemble/forecast",
resolution="hh",
time_zone="WET",
currency="GBP",
enable_settlement_period=True,
time_display={
"mode": "rolling",
"periodback": "daily",
"amountback": 4,
"periodfor": "min",
"amountfor": 4,
},
)
df_rolling = rolling_chart.to_df()
CSV chart requests also take units, spelled as on the Bulk API
(Units). Only units offered in the chart's Units dropdown, in the
requested currency, are applied; anything else raises ValidationError
instead of silently returning the base unit:
coal_chart = client.chart.get(
"csv",
code="de/elec/spectron/coal",
start_dt="2026-09-01T00:00",
end_dt="2026-09-02T00:00",
resolution="daily",
time_zone="CET",
currency="EUR",
units="EUR/MWh 55% Eff",
)
Price Volume Curves
The Price Volume Curve API retrieves auction price-volume curve data for a given timestamp.
hu_price_volume_curve = client.price_volume_curve.get(
"csv",
code="hu/elec/ancillary/capacity/afrr/daily/up",
dt="2025-01-01T00:00",
time_zone="CET",
currency="EUR",
)
df_curve = hu_price_volume_curve.to_df()
The dt parameter represents the auction timestamp for which the curve should be retrieved.
EPEX Trade Evolution And Contracts
The EPEX service uses the apxdownload endpoint and is exposed as client.epex. It currently supports settlement trade evolution downloads and contract evolution downloads in "csv", "json", and "xml" formats.
Settlement trade evolution is available under client.epex.settlement. You can identify a quarter-hour either with settlement_date plus settlement_period, or with a single settlement_datetime:
trade_evo = client.epex.settlement.get(
"csv",
code="nl/elec/epex/tradeevo/download",
settlement_datetime="2025-01-01T12:07",
max_points=200,
time_zone="CET",
)
trade_evo_df = trade_evo.to_df(
rename_columns=["qh_price", "qh_vol", "hh_price", "hh_vol", "hr_price", "hr_vol"],
unit_in_columns=True,
)
Contract evolution is available under client.epex.contract:
contract_evo = client.epex.contract.get(
"csv",
code="nl/elec/spectron/power/baseload/evolution/download",
contract="DEC-25",
max_points="all",
time_zone="CET",
)
contract_evo_df = contract_evo.to_df(unit_in_columns=True)
Asynchronous
An asynchronous client (EnAppSysAsync) is available for non-blocking and concurrent request execution.
The asynchronous interface is currently under active development. Usage examples and extended documentation will be added in a future release.
License
This project is licensed under the terms of the MIT license.
Metadata
Release files for enappsys 0.3.0
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| enappsys-0.3.0.tar.gz | 38.3 kB | With provenance | Details for enappsys-0.3.0.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| enappsys-0.3.0-py3-none-any.whl | Python 3 | none | any | Details for enappsys-0.3.0-py3-none-any.whl |
Total release size: 83.7 kB
Release files / enappsys-0.3.0.tar.gz
| Download URL | enappsys-0.3.0.tar.gz |
|---|---|
| Size | 38.3 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
140ab0445978d5499836a02eaa6ebfe6bbadff00e8fc34423ee1de9bd3c23f28
|
|
BLAKE2b-256 checksum How to use checksums |
0f4ea7ef815ba9441685d3ac1d34db6bd769b387b18dc0dff97c9885298c16e0
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.14
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Sep 29, 2026.
Transparency logRelease files / enappsys-0.3.0-py3-none-any.whl
| Download URL | enappsys-0.3.0-py3-none-any.whl |
|---|---|
| Size | 45.4 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
d2fba6d800cab2a66503f4708528089acd960386700658ea1b93ab338fad1d03
|
|
BLAKE2b-256 checksum How to use checksums |
d0672afd880b7835d76e43397f520248b35318fc840dbfe74fef225f48a71e78
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.14
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Sep 29, 2026.
Transparency logSecurity for enappsys 0.3.0
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
Full provenance
Both files in this release have been uploaded with provenance metadata.
Attestation for enappsys-0.3.0.tar.gz
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Sep 29, 2026.
Transparency logA note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.