Integrations

CREATE DATABASE eolas
  FROM SHARE MRWTYQY-WZ79363.vs_warehouse_share;

SELECT * FROM eolas.rbnz.rbnz_b1_exchange_rates_monthly
WHERE date >= '2020-01-01';

Queryable from anything that talks Snowflake — Tableau, dbt, Power BI, Sigma, Mode. Full setup guide → · Enterprise overview →

pip install eolas-data[cli]
eolas get rbnz_b1_exchange_rates_monthly \
  --format parquet --out ./raw/rbnz_fx.parquet
# then load with your usual target (dbt, COPY, etc.)

An experimental eolas integrate meltano scaffold (Enterprise) is available on request — not the primary path. Prefer clients + your existing runner. Enterprise overview →

GET https://api.eolas.fyi/v1/datasets/rbnz_b1_exchange_rates_monthly/data
Header: X-API-Key: <your-key>
# Or schedule: eolas get … --format parquet → Blob → Copy activity

Experimental ADF JSON scaffolds via eolas integrate azure-data-factory (Enterprise) available on request. Enterprise overview →

pip install fivetran-connector-sdk requests

from fivetran_connector_sdk import Connector, Operations as op
import requests

BASE = "https://api.eolas.fyi/v1/datasets"

# List the series you want to sync
SERIES = ["rbnz_b1_exchange_rates_monthly", "rbnz_m5_gdp", "rbnz_b20_mortgage_rates"]

def schema(configuration):
    return [{"table": name, "primary_key": ["date"]} for name in SERIES]

def update(configuration, state):
    api_key = configuration["api_key"]
    for name in SERIES:
        rows = requests.get(
            f"{BASE}/{name}/data",
            headers={"X-API-Key": api_key}
        ).json()
        for row in rows:
            yield op.upsert(name, row)
    yield op.checkpoint({})

connector = Connector(update=update, schema=schema)

if __name__ == "__main__":
    connector.debug()

python connector.py debug

In the Fivetran dashboard: Connectors → Add connector → Connector SDK, upload connector.py and set api_key in the configuration.

sources:
  - name: eolas_rbnz
    database: eolas
    schema: rbnz
    tables:
      - name: rbnz_b1_exchange_rates_monthly
      - name: rbnz_m5_gdp

-- models/exchange_rate_trend.sql
SELECT
    date,
    nzd_usd
FROM {{ source('eolas_rbnz', 'rbnz_b1_exchange_rates_monthly') }}
WHERE date >= '2015-01-01'
ORDER BY date

dbt run --select exchange_rate_trend

from airflow.decorators import dag, task
from airflow.models import Variable
from datetime import datetime
import requests, pandas as pd
from sqlalchemy import create_engine

SERIES = ["rbnz_b1_exchange_rates_monthly", "rbnz_m5_gdp", "rbnz_b20_mortgage_rates"]
BASE   = "https://api.eolas.fyi/v1/datasets"

@dag(schedule="@daily", start_date=datetime(2024, 1, 1), catchup=False)
def eolas_sync():

    @task
    def fetch_and_load(name: str):
        api_key = Variable.get("EOLAS_API_KEY")
        rows = requests.get(
            f"{BASE}/{name}/data",
            headers={"X-API-Key": api_key},
            timeout=60,
        ).json()
        df = pd.DataFrame(rows)
        engine = create_engine(Variable.get("WAREHOUSE_CONN"))
        df.to_sql(name, engine, schema="eolas",
                  if_exists="replace", index=False)

    for s in SERIES:
        fetch_and_load(s)

eolas_sync()

Set EOLAS_API_KEY and WAREHOUSE_CONN as Airflow Variables in Admin → Variables.

pip install prefect requests pandas

from prefect import flow, task
import requests, pandas as pd

BASE    = "https://api.eolas.fyi/v1/datasets"
API_KEY = "your_key_here"
SERIES  = ["rbnz_b1_exchange_rates_monthly", "rbnz_m5_gdp"]

@task(retries=3, retry_delay_seconds=10)
def fetch_dataset(name: str) -> pd.DataFrame:
    rows = requests.get(
        f"{BASE}/{name}/data",
        headers={"X-API-Key": API_KEY},
        timeout=60,
    ).json()
    return pd.DataFrame(rows)

@task
def save(df: pd.DataFrame, name: str):
    df.to_parquet(f"{name}.parquet", index=False)
    print(f"Saved {len(df)} rows → {name}.parquet")

@flow(name="eolas-sync")
def sync():
    for name in SERIES:
        df = fetch_dataset(name)
        save(df, name)

if __name__ == "__main__":
    sync.serve(name="daily-sync", cron="0 6 * * *")

pip install eolas-data pandas matplotlib

from eolas_data import Client
import matplotlib.pyplot as plt

client = Client("your_key_here")

fx   = client.get("rbnz_b1_exchange_rates_monthly", start="2010-01-01")
gdp  = client.get("rbnz_m5_gdp", start="2010-01-01")

fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 6))
ax1.plot(fx["date"], fx["nzd_usd"])
ax1.set_title("NZD/USD Exchange Rate (monthly)")
ax2.plot(gdp["date"], gdp["value"])
ax2.set_title("NZ GDP (RBNZ M5)")
plt.tight_layout()
plt.show()

import pandas as pd
from eolas_data import Client

client = Client("your_key_here")
series = ["rbnz_b1_exchange_rates_monthly", "rbnz_m5_gdp", "rbnz_b20_mortgage_rates"]

df = pd.concat(
    [client.get(s, start="2015-01-01").assign(series=s) for s in series]
).pivot(index="date", columns="series", values="value")

print(df.tail())

pip install duckdb

import duckdb

API_KEY = "your_key_here"

con = duckdb.connect()

df = con.execute("""
    SELECT *
    FROM read_json_auto(
        'https://api.eolas.fyi/v1/datasets/rbnz_b1_exchange_rates_monthly/data?limit=1000',
        headers = {'X-API-Key': '""" + API_KEY + """'}
    )
    WHERE date >= '2015-01-01'
    ORDER BY date
""").df()

print(df.tail())

import duckdb

API_KEY = "your_key_here"
SERIES = ["rbnz_b1_exchange_rates_monthly", "rbnz_m5_gdp", "rbnz_b20_mortgage_rates"]
BASE   = "https://api.eolas.fyi/v1/datasets"

con = duckdb.connect()
con.execute("CREATE TABLE economic_data AS SELECT * FROM range(0) LIMIT 0")

for name in SERIES:
    con.execute(f"""
        INSERT INTO economic_data
        SELECT *, '{name}' AS series_name
        FROM read_json_auto(
            '{BASE}/{name}/data?limit=1000',
            headers = {{'X-API-Key': '{API_KEY}'}}
        )
    """)

print(con.execute("SELECT series_name, COUNT(*) FROM economic_data GROUP BY 1").df())

pip install requests pandas sqlalchemy redshift-connector

import requests, pandas as pd
from sqlalchemy import create_engine

API_KEY  = "your_key_here"
REDSHIFT = "redshift+redshift_connector://user:pass@host:5439/dbname"
SERIES   = ["rbnz_b1_exchange_rates_monthly", "rbnz_m5_gdp", "rbnz_b20_mortgage_rates"]
BASE     = "https://api.eolas.fyi/v1/datasets"

engine = create_engine(REDSHIFT)

for name in SERIES:
    rows = requests.get(
        f"{BASE}/{name}/data",
        headers={"X-API-Key": API_KEY},
        timeout=60,
    ).json()
    df = pd.DataFrame(rows)
    df.to_sql(name, engine, schema="eolas",
              if_exists="replace", index=False, method="multi")
    print(f"Loaded {len(df)} rows → eolas.{name}")

For large datasets, consider staging via S3 and using COPY instead of row-by-row inserts — it's significantly faster on Redshift.

pip install requests pandas google-cloud-bigquery pyarrow

import requests, pandas as pd
from google.cloud import bigquery

API_KEY  = "your_key_here"
PROJECT  = "your-gcp-project"
DATASET  = "eolas"
SERIES   = ["rbnz_b1_exchange_rates_monthly", "rbnz_m5_gdp", "rbnz_b20_mortgage_rates"]
BASE     = "https://api.eolas.fyi/v1/datasets"

client = bigquery.Client(project=PROJECT)

# Create dataset if it doesn't exist
client.create_dataset(bigquery.Dataset(f"{PROJECT}.{DATASET}"), exists_ok=True)

for name in SERIES:
    rows = requests.get(
        f"{BASE}/{name}/data",
        headers={"X-API-Key": API_KEY},
        timeout=60,
    ).json()
    df = pd.DataFrame(rows)

    table_id = f"{PROJECT}.{DATASET}.{name}"
    job_config = bigquery.LoadJobConfig(write_disposition="WRITE_TRUNCATE")
    job = client.load_table_from_dataframe(df, table_id, job_config=job_config)
    job.result()
    print(f"Loaded {len(df)} rows → {table_id}")

Authenticate with gcloud auth application-default login locally, or set GOOGLE_APPLICATION_CREDENTIALS to a service account key file in production.

import requests, pandas as pd

API_KEY = dbutils.secrets.get(scope="eolas", key="api-key")
SERIES  = ["rbnz_b1_exchange_rates_monthly", "rbnz_m5_gdp", "rbnz_b20_mortgage_rates"]
BASE    = "https://api.eolas.fyi/v1/datasets"

for name in SERIES:
    rows = requests.get(
        f"{BASE}/{name}/data",
        headers={"X-API-Key": API_KEY},
        timeout=60,
    ).json()
    pdf = pd.DataFrame(rows)
    sdf = spark.createDataFrame(pdf)
    sdf.write.format("delta").mode("overwrite").saveAsTable(f"eolas.{name}")
    print(f"Saved {pdf.shape[0]} rows → eolas.{name}")

pip install requests pandas databricks-sql-connector

import requests, pandas as pd
from databricks import sql

API_KEY    = "your_eolas_api_key"
DB_HOST    = "your-workspace.azuredatabricks.net"
HTTP_PATH  = "/sql/1.0/warehouses/your_warehouse_id"
DB_TOKEN   = "your_databricks_token"

conn = sql.connect(server_hostname=DB_HOST, http_path=HTTP_PATH, access_token=DB_TOKEN)
cursor = conn.cursor()

SERIES = ["rbnz_b1_exchange_rates_monthly", "rbnz_m5_gdp"]
BASE   = "https://api.eolas.fyi/v1/datasets"

for name in SERIES:
    rows = requests.get(f"{BASE}/{name}/data", headers={"X-API-Key": API_KEY}, timeout=60).json()
    df = pd.DataFrame(rows)
    cols = ", ".join(f"{c} STRING" for c in df.columns)
    cursor.execute(f"CREATE TABLE IF NOT EXISTS eolas.{name} ({cols})")
    cursor.execute(f"DELETE FROM eolas.{name}")
    data = [tuple(str(v) for v in row) for row in df.itertuples(index=False)]
    placeholders = ", ".join(["?"] * len(df.columns))
    cursor.executemany(f"INSERT INTO eolas.{name} VALUES ({placeholders})", data)

conn.close()