Forstify External API

// Node.js 22+ (built-in fetch) · npm install express @types/express

import express from 'express';

const API_BASE = 'https://app.forstify.de/external/api/v1';
const API_KEY  = process.env.FORSTIFY_API_KEY!;

const app = express();

app.get('/forstify-version', async (_req, res) => {
  const response = await fetch(`${API_BASE}/version`, {
    headers: { 'X-API-KEY': API_KEY },
  });

  if (!response.ok) {
    return res.status(response.status).json(await response.json());
  }

  res.json(await response.json());
});

// Spring Boot 3.2+ · spring-boot-starter-web

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestClient;

import java.util.Map;

@Service
public class ForstifyClient {

    private final RestClient restClient;

    public ForstifyClient(@Value("${forstify.api-key}") String apiKey) {
        this.restClient = RestClient.builder()
                .baseUrl("https://app.forstify.de/external/api/v1")
                .defaultHeader("X-API-KEY", apiKey)
                .build();
    }

    public Map<String, String> getVersion() {
        return restClient.get()
                .uri("/version")
                .retrieve()
                .body(new org.springframework.core.ParameterizedTypeReference<>() {});
    }
}

# pip install requests

import os
import requests

class ForstifyClient:
    BASE_URL = "https://app.forstify.de/external/api/v1"

    def __init__(self):
        self._session = requests.Session()
        self._session.headers["X-API-KEY"] = os.environ["FORSTIFY_API_KEY"]

    def get_version(self) -> dict:
        resp = self._session.get(f"{self.BASE_URL}/version")
        resp.raise_for_status()
        return resp.json()


# Usage
client = ForstifyClient()
version = client.get_version()
print(version["backendVersion"])

// stdlib only

package forstify

import (
    "encoding/json"
    "fmt"
    "net/http"
    "os"
    "time"
)

type Client struct {
    baseURL string
    apiKey  string
    http    *http.Client
}

func NewClient() *Client {
    return &Client{
        baseURL: "https://app.forstify.de/external/api/v1",
        apiKey:  os.Getenv("FORSTIFY_API_KEY"),
        http:    &http.Client{Timeout: 30 * time.Second},
    }
}

type VersionResponse struct {
    BackendVersion string `json:"backendVersion"`
    APIVersion     string `json:"apiVersion"`
}

func (c *Client) GetVersion() (*VersionResponse, error) {
    req, _ := http.NewRequest(http.MethodGet, c.baseURL+"/version", nil)
    req.Header.Set("X-API-KEY", c.apiKey)

    resp, err := c.http.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("forstify: %s", resp.Status)
    }

    var result VersionResponse
    json.NewDecoder(resp.Body).Decode(&result)
    return &result, nil
}

app.get('/measurements', async (req, res) => {
  const params = new URLSearchParams({
    limit:     String(req.query.limit     ?? 20),
    offset:    String(req.query.offset    ?? 0),
    sortBy:    String(req.query.sortBy    ?? 'createdAt'),
    sortOrder: String(req.query.sortOrder ?? 'DESC'),
  });

  const response = await fetch(`${API_BASE}/measurements?${params}`, {
    headers: { 'X-API-KEY': API_KEY },
  });

  if (response.status === 304) return res.status(304).end();
  if (!response.ok) return res.status(response.status).json(await response.json());

  res.json(await response.json());
});

// Inside ForstifyClient - see GET /version for full class setup

import org.springframework.core.ParameterizedTypeReference;
import java.util.List;
import java.util.Map;

public Map<String, Object> getMeasurements(
        int limit, int offset, String sortBy, String sortOrder) {

    return restClient.get()
            .uri(u -> u.path("/measurements")
                    .queryParam("limit",     limit)
                    .queryParam("offset",    offset)
                    .queryParam("sortBy",    sortBy)
                    .queryParam("sortOrder", sortOrder)
                    .build())
            .retrieve()
            .body(new ParameterizedTypeReference<>() {});
}

# Inside ForstifyClient - see GET /version for full class setup

def get_measurements(
    self,
    limit: int = 20,
    offset: int = 0,
    sort_by: str = "createdAt",
    sort_order: str = "DESC",
) -> dict:
    resp = self._session.get(
        f"{self.BASE_URL}/measurements",
        params={"limit": limit, "offset": offset, "sortBy": sort_by, "sortOrder": sort_order},
    )
    resp.raise_for_status()
    return resp.json()

// Inside Client - see GET /version for full struct setup

import (
    "encoding/json"
    "fmt"
    "net/http"
    "net/url"
    "strconv"
)

type Pagination struct {
    Count  int `json:"count"`
    Limit  int `json:"limit"`
    Offset int `json:"offset"`
    Total  int `json:"total"`
}

type PaginatedResult struct {
    Data       []map[string]any `json:"data"`
    Pagination Pagination       `json:"pagination"`
}

func (c *Client) GetMeasurements(limit, offset int, sortBy, sortOrder string) (*PaginatedResult, error) {
    q := url.Values{}
    q.Set("limit",     strconv.Itoa(limit))
    q.Set("offset",    strconv.Itoa(offset))
    q.Set("sortBy",    sortBy)
    q.Set("sortOrder", sortOrder)

    req, _ := http.NewRequest(http.MethodGet, c.baseURL+"/measurements?"+q.Encode(), nil)
    req.Header.Set("X-API-KEY", c.apiKey)

    resp, err := c.http.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("forstify: %s", resp.Status)
    }

    var result PaginatedResult
    json.NewDecoder(resp.Body).Decode(&result)
    return &result, nil
}

// Simple in-memory ETag store - use Redis / DB in production
const etagCache = new Map<string, string>();

app.get('/measurements/overview', async (req, res) => {
  const params = new URLSearchParams({
    limit:     String(req.query.limit     ?? 20),
    offset:    String(req.query.offset    ?? 0),
    sortBy:    String(req.query.sortBy    ?? 'createdAt'),
    sortOrder: String(req.query.sortOrder ?? 'DESC'),
  });

  const cacheKey   = params.toString();
  const headers: Record<string, string> = { 'X-API-KEY': API_KEY };
  const storedEtag = etagCache.get(cacheKey);
  if (storedEtag) headers['If-None-Match'] = storedEtag;

  const response = await fetch(`${API_BASE}/measurements/overview?${params}`, { headers });

  if (response.status === 304) return res.status(304).end();
  if (!response.ok) return res.status(response.status).json(await response.json());

  const etag = response.headers.get('etag');
  if (etag) etagCache.set(cacheKey, etag);

  res.json(await response.json());
});

// Inside ForstifyClient - see GET /version for full class setup

import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;

import java.util.Optional;

public Optional<ResponseEntity<?>> getMeasurementsOverview(
        int limit, int offset, String sortBy, String sortOrder, String etag) {

    return restClient.get()
            .uri(u -> u.path("/measurements/overview")
                    .queryParam("limit",     limit)
                    .queryParam("offset",    offset)
                    .queryParam("sortBy",    sortBy)
                    .queryParam("sortOrder", sortOrder)
                    .build())
            .headers(h -> { if (etag != null) h.setIfNoneMatch(etag); })
            .exchange((req, resp) -> {
                if (resp.getStatusCode() == HttpStatus.NOT_MODIFIED) {
                    return Optional.empty();
                }
                return Optional.of(resp.bodyTo(new ParameterizedTypeReference<>() {}));
            });
}

# Inside ForstifyClient - see GET /version for full class setup
# Returns (data, new_etag). data is None on 304 Not Modified.

from typing import Optional

def get_measurements_overview(
    self,
    limit: int = 20,
    offset: int = 0,
    sort_by: str = "createdAt",
    sort_order: str = "DESC",
    etag: Optional[str] = None,
) -> tuple[Optional[dict], Optional[str]]:
    headers = {}
    if etag:
        headers["If-None-Match"] = etag

    resp = self._session.get(
        f"{self.BASE_URL}/measurements/overview",
        params={"limit": limit, "offset": offset, "sortBy": sort_by, "sortOrder": sort_order},
        headers=headers,
    )

    if resp.status_code == 304:
        return None, etag

    resp.raise_for_status()
    return resp.json(), resp.headers.get("ETag")

// Inside Client - see GET /version for full struct setup
// Returns (result, newEtag, error). result is nil on 304 Not Modified.

func (c *Client) GetMeasurementsOverview(
    limit, offset int, sortBy, sortOrder, etag string,
) (*PaginatedResult, string, error) {

    q := url.Values{}
    q.Set("limit",     strconv.Itoa(limit))
    q.Set("offset",    strconv.Itoa(offset))
    q.Set("sortBy",    sortBy)
    q.Set("sortOrder", sortOrder)

    req, _ := http.NewRequest(http.MethodGet, c.baseURL+"/measurements/overview?"+q.Encode(), nil)
    req.Header.Set("X-API-KEY", c.apiKey)
    if etag != "" {
        req.Header.Set("If-None-Match", etag)
    }

    resp, err := c.http.Do(req)
    if err != nil {
        return nil, "", err
    }
    defer resp.Body.Close()

    if resp.StatusCode == http.StatusNotModified {
        return nil, etag, nil
    }
    if resp.StatusCode != http.StatusOK {
        return nil, "", fmt.Errorf("forstify: %s", resp.Status)
    }

    newEtag := resp.Header.Get("ETag")
    var result PaginatedResult
    json.NewDecoder(resp.Body).Decode(&result)
    return &result, newEtag, nil
}

app.get('/measurements/search', async (req, res) => {
  const { id, number } = req.query as Record<string, string>;

  if (!id && !number) {
    return res.status(400).json({ message: 'id or number required' });
  }

  const params = new URLSearchParams();
  if (id)     params.set('id', id);
  if (number) params.set('number', number);

  const response = await fetch(`${API_BASE}/measurements/search?${params}`, {
    headers: { 'X-API-KEY': API_KEY },
  });

  if (response.status === 304) return res.status(304).end();
  if (response.status === 404) return res.status(404).json({ message: 'not found' });
  if (!response.ok) return res.status(response.status).json(await response.json());

  res.json(await response.json());
});

// Inside ForstifyClient - see GET /version for full class setup

import org.springframework.core.ParameterizedTypeReference;
import org.springframework.web.util.UriComponentsBuilder;
import java.util.Map;

public Map<String, Object> searchMeasurement(String id, String number) {
    if (id == null && number == null) {
        throw new IllegalArgumentException("id or number is required");
    }

    UriComponentsBuilder uri = UriComponentsBuilder.fromPath("/measurements/search");
    if (id != null)     uri.queryParam("id",     id);
    if (number != null) uri.queryParam("number", number);

    return restClient.get()
            .uri(uri.build().toUri())
            .retrieve()
            .body(new ParameterizedTypeReference<>() {});
}

# Inside ForstifyClient - see GET /version for full class setup

from typing import Optional

def search_measurement(
    self, id: Optional[str] = None, number: Optional[str] = None
) -> dict:
    if not id and not number:
        raise ValueError("id or number is required")

    params = {}
    if id:     params["id"]     = id
    if number: params["number"] = number

    resp = self._session.get(f"{self.BASE_URL}/measurements/search", params=params)

    if resp.status_code == 404:
        return None

    resp.raise_for_status()
    return resp.json()

// Inside Client - see GET /version for full struct setup

func (c *Client) SearchMeasurement(id, number string) (map[string]any, error) {
    if id == "" && number == "" {
        return nil, fmt.Errorf("id or number is required")
    }

    q := url.Values{}
    if id != ""     { q.Set("id",     id)     }
    if number != "" { q.Set("number", number) }

    req, _ := http.NewRequest(http.MethodGet, c.baseURL+"/measurements/search?"+q.Encode(), nil)
    req.Header.Set("X-API-KEY", c.apiKey)

    resp, err := c.http.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode == http.StatusNotFound {
        return nil, nil
    }
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("forstify: %s", resp.Status)
    }

    var result map[string]any
    json.NewDecoder(resp.Body).Decode(&result)
    return result, nil
}

app.get('/measurements/:id', async (req, res) => {
  const response = await fetch(`${API_BASE}/measurements/${req.params.id}`, {
    headers: { 'X-API-KEY': API_KEY },
  });

  if (response.status === 404) return res.status(404).json({ message: 'not found' });
  if (!response.ok) return res.status(response.status).json(await response.json());

  res.json(await response.json());
});

// Inside ForstifyClient - see GET /version for full class setup

import org.springframework.core.ParameterizedTypeReference;
import java.util.Map;

public Map<String, Object> getMeasurement(String id) {
    return restClient.get()
            .uri("/measurements/{id}", id)
            .retrieve()
            .body(new ParameterizedTypeReference<>() {});
}

# Inside ForstifyClient - see GET /version for full class setup

def get_measurement(self, id: str) -> dict:
    resp = self._session.get(f"{self.BASE_URL}/measurements/{id}")

    if resp.status_code == 404:
        return None

    resp.raise_for_status()
    return resp.json()

// Inside Client - see GET /version for full struct setup

func (c *Client) GetMeasurement(id string) (map[string]any, error) {
    req, _ := http.NewRequest(http.MethodGet, c.baseURL+"/measurements/"+id, nil)
    req.Header.Set("X-API-KEY", c.apiKey)

    resp, err := c.http.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode == http.StatusNotFound {
        return nil, nil
    }
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("forstify: %s", resp.Status)
    }

    var result map[string]any
    json.NewDecoder(resp.Body).Decode(&result)
    return result, nil
}

app.get('/woodlists', async (req, res) => {
  const params = new URLSearchParams({
    limit:     String(req.query.limit     ?? 20),
    offset:    String(req.query.offset    ?? 0),
    sortBy:    String(req.query.sortBy    ?? 'createdAt'),
    sortOrder: String(req.query.sortOrder ?? 'DESC'),
  });

  const response = await fetch(`${API_BASE}/woodlists?${params}`, {
    headers: { 'X-API-KEY': API_KEY },
  });

  if (response.status === 304) return res.status(304).end();
  if (!response.ok) return res.status(response.status).json(await response.json());

  res.json(await response.json());
});

// Inside ForstifyClient - see GET /version for full class setup

public Map<String, Object> getWoodLists(
        int limit, int offset, String sortBy, String sortOrder) {

    return restClient.get()
            .uri(u -> u.path("/woodlists")
                    .queryParam("limit",     limit)
                    .queryParam("offset",    offset)
                    .queryParam("sortBy",    sortBy)
                    .queryParam("sortOrder", sortOrder)
                    .build())
            .retrieve()
            .body(new org.springframework.core.ParameterizedTypeReference<>() {});
}

# Inside ForstifyClient - see GET /version for full class setup

def get_woodlists(
    self,
    limit: int = 20,
    offset: int = 0,
    sort_by: str = "createdAt",
    sort_order: str = "DESC",
) -> dict:
    resp = self._session.get(
        f"{self.BASE_URL}/woodlists",
        params={"limit": limit, "offset": offset, "sortBy": sort_by, "sortOrder": sort_order},
    )
    resp.raise_for_status()
    return resp.json()

// Inside Client - see GET /version for full struct setup

func (c *Client) GetWoodLists(limit, offset int, sortBy, sortOrder string) (*PaginatedResult, error) {
    q := url.Values{}
    q.Set("limit",     strconv.Itoa(limit))
    q.Set("offset",    strconv.Itoa(offset))
    q.Set("sortBy",    sortBy)
    q.Set("sortOrder", sortOrder)

    req, _ := http.NewRequest(http.MethodGet, c.baseURL+"/woodlists?"+q.Encode(), nil)
    req.Header.Set("X-API-KEY", c.apiKey)

    resp, err := c.http.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("forstify: %s", resp.Status)
    }

    var result PaginatedResult
    json.NewDecoder(resp.Body).Decode(&result)
    return &result, nil
}

app.get('/woodlists/overview', async (req, res) => {
  const params = new URLSearchParams({
    limit:     String(req.query.limit     ?? 20),
    offset:    String(req.query.offset    ?? 0),
    sortBy:    String(req.query.sortBy    ?? 'createdAt'),
    sortOrder: String(req.query.sortOrder ?? 'DESC'),
  });

  const response = await fetch(`${API_BASE}/woodlists/overview?${params}`, {
    headers: { 'X-API-KEY': API_KEY },
  });

  if (response.status === 304) return res.status(304).end();
  if (!response.ok) return res.status(response.status).json(await response.json());

  res.json(await response.json());
});

// Inside ForstifyClient - see GET /version for full class setup

public Map<String, Object> getWoodListsOverview(
        int limit, int offset, String sortBy, String sortOrder, String etag) {

    return restClient.get()
            .uri(u -> u.path("/woodlists/overview")
                    .queryParam("limit",     limit)
                    .queryParam("offset",    offset)
                    .queryParam("sortBy",    sortBy)
                    .queryParam("sortOrder", sortOrder)
                    .build())
            .headers(h -> { if (etag != null) h.setIfNoneMatch(etag); })
            .retrieve()
            .body(new org.springframework.core.ParameterizedTypeReference<>() {});
}

# Inside ForstifyClient - see GET /version for full class setup

from typing import Optional

def get_woodlists_overview(
    self,
    limit: int = 20,
    offset: int = 0,
    sort_by: str = "createdAt",
    sort_order: str = "DESC",
    etag: Optional[str] = None,
) -> tuple[Optional[dict], Optional[str]]:
    headers = {}
    if etag:
        headers["If-None-Match"] = etag

    resp = self._session.get(
        f"{self.BASE_URL}/woodlists/overview",
        params={"limit": limit, "offset": offset, "sortBy": sort_by, "sortOrder": sort_order},
        headers=headers,
    )

    if resp.status_code == 304:
        return None, etag

    resp.raise_for_status()
    return resp.json(), resp.headers.get("ETag")

// Inside Client - see GET /version for full struct setup

func (c *Client) GetWoodListsOverview(
    limit, offset int, sortBy, sortOrder, etag string,
) (*PaginatedResult, string, error) {

    q := url.Values{}
    q.Set("limit",     strconv.Itoa(limit))
    q.Set("offset",    strconv.Itoa(offset))
    q.Set("sortBy",    sortBy)
    q.Set("sortOrder", sortOrder)

    req, _ := http.NewRequest(http.MethodGet, c.baseURL+"/woodlists/overview?"+q.Encode(), nil)
    req.Header.Set("X-API-KEY", c.apiKey)
    if etag != "" {
        req.Header.Set("If-None-Match", etag)
    }

    resp, err := c.http.Do(req)
    if err != nil {
        return nil, "", err
    }
    defer resp.Body.Close()

    if resp.StatusCode == http.StatusNotModified {
        return nil, etag, nil
    }
    if resp.StatusCode != http.StatusOK {
        return nil, "", fmt.Errorf("forstify: %s", resp.Status)
    }

    newEtag := resp.Header.Get("ETag")
    var result PaginatedResult
    json.NewDecoder(resp.Body).Decode(&result)
    return &result, newEtag, nil
}

app.get('/woodlists/search', async (req, res) => {
  const { id, shareId, title } = req.query as Record<string, string>;

  if (!id && !shareId && !title) {
    return res.status(400).json({ message: 'id, shareId or title required' });
  }

  const params = new URLSearchParams();
  if (id)      params.set('id',      id);
  if (shareId) params.set('shareId', shareId);
  if (title)   params.set('title',   title);

  const response = await fetch(`${API_BASE}/woodlists/search?${params}`, {
    headers: { 'X-API-KEY': API_KEY },
  });

  if (response.status === 304) return res.status(304).end();
  if (response.status === 404) return res.status(404).json({ message: 'not found' });
  if (!response.ok) return res.status(response.status).json(await response.json());

  res.json(await response.json());
});

// Inside ForstifyClient - see GET /version for full class setup

import org.springframework.core.ParameterizedTypeReference;
import org.springframework.web.util.UriComponentsBuilder;
import java.util.Map;

public Map<String, Object> searchWoodList(String id, String shareId, String title) {
    if (id == null && shareId == null && title == null) {
        throw new IllegalArgumentException("id, shareId or title is required");
    }

    UriComponentsBuilder uri = UriComponentsBuilder.fromPath("/woodlists/search");
    if (id      != null) uri.queryParam("id",      id);
    if (shareId != null) uri.queryParam("shareId", shareId);
    if (title   != null) uri.queryParam("title",   title);

    return restClient.get()
            .uri(uri.build().toUri())
            .retrieve()
            .body(new ParameterizedTypeReference<>() {});
}

# Inside ForstifyClient - see GET /version for full class setup

from typing import Optional

def search_woodlist(
    self,
    id: Optional[str] = None,
    share_id: Optional[str] = None,
    title: Optional[str] = None,
) -> Optional[dict]:
    if not id and not share_id and not title:
        raise ValueError("id, share_id or title is required")

    params = {}
    if id:       params["id"]      = id
    if share_id: params["shareId"] = share_id
    if title:    params["title"]   = title

    resp = self._session.get(f"{self.BASE_URL}/woodlists/search", params=params)

    if resp.status_code == 404:
        return None

    resp.raise_for_status()
    return resp.json()

// Inside Client - see GET /version for full struct setup

func (c *Client) SearchWoodList(id, shareID, title string) (map[string]any, error) {
    if id == "" && shareID == "" && title == "" {
        return nil, fmt.Errorf("id, shareID or title is required")
    }

    q := url.Values{}
    if id != ""      { q.Set("id",      id)      }
    if shareID != "" { q.Set("shareId", shareID) }
    if title != ""   { q.Set("title",   title)   }

    req, _ := http.NewRequest(http.MethodGet, c.baseURL+"/woodlists/search?"+q.Encode(), nil)
    req.Header.Set("X-API-KEY", c.apiKey)

    resp, err := c.http.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode == http.StatusNotFound {
        return nil, nil
    }
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("forstify: %s", resp.Status)
    }

    var result map[string]any
    json.NewDecoder(resp.Body).Decode(&result)
    return result, nil
}

app.get('/woodlists/:id', async (req, res) => {
  const response = await fetch(`${API_BASE}/woodlists/${req.params.id}`, {
    headers: { 'X-API-KEY': API_KEY },
  });

  if (response.status === 404) return res.status(404).json({ message: 'not found' });
  if (!response.ok) return res.status(response.status).json(await response.json());

  res.json(await response.json());
});

// Inside ForstifyClient - see GET /version for full class setup

import org.springframework.core.ParameterizedTypeReference;
import java.util.Map;

public Map<String, Object> getWoodList(String id) {
    return restClient.get()
            .uri("/woodlists/{id}", id)
            .retrieve()
            .body(new ParameterizedTypeReference<>() {});
}

# Inside ForstifyClient - see GET /version for full class setup

def get_wood_list(self, id: str) -> dict:
    resp = self._session.get(f"{self.BASE_URL}/woodlists/{id}")

    if resp.status_code == 404:
        return None

    resp.raise_for_status()
    return resp.json()

// Inside Client - see GET /version for full struct setup

func (c *Client) GetWoodList(id string) (map[string]any, error) {
    req, _ := http.NewRequest(http.MethodGet, c.baseURL+"/woodlists/"+id, nil)
    req.Header.Set("X-API-KEY", c.apiKey)

    resp, err := c.http.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode == http.StatusNotFound {
        return nil, nil
    }
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("forstify: %s", resp.Status)
    }

    var result map[string]any
    json.NewDecoder(resp.Body).Decode(&result)
    return result, nil
}

app.get('/images/:id', async (req, res) => {
  const response = await fetch(`${API_BASE}/images/${req.params.id}`, {
    headers: { 'X-API-KEY': API_KEY },
  });

  if (!response.ok) return res.status(response.status).json(await response.json());

  res.setHeader('Content-Type', 'image/jpeg');
  res.send(Buffer.from(await response.arrayBuffer()));
});

// Inside ForstifyClient - see GET /version for full class setup

public byte[] getImage(String id) {
    return restClient.get()
            .uri("/images/{id}", id)
            .retrieve()
            .body(byte[].class);
}

# Inside ForstifyClient - see GET /version for full class setup

def get_image(self, id: str) -> bytes:
    resp = self._session.get(f"{self.BASE_URL}/images/{id}")
    resp.raise_for_status()
    return resp.content

// Inside Client - see GET /version for full struct setup

func (c *Client) GetImage(id string) ([]byte, error) {
    req, _ := http.NewRequest(http.MethodGet, c.baseURL+"/images/"+id, nil)
    req.Header.Set("X-API-KEY", c.apiKey)

    resp, err := c.http.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("forstify: %s", resp.Status)
    }

    return io.ReadAll(resp.Body)
}

app.get('/images/:id/:width/:height', async (req, res) => {
  const { id, width, height } = req.params;
  const response = await fetch(`${API_BASE}/images/${id}/${width}/${height}`, {
    headers: { 'X-API-KEY': API_KEY },
  });

  if (!response.ok) return res.status(response.status).json(await response.json());

  res.setHeader('Content-Type', 'image/jpeg');
  res.send(Buffer.from(await response.arrayBuffer()));
});

// Inside ForstifyClient - see GET /version for full class setup

public byte[] getScaledImage(String id, int width, int height) {
    return restClient.get()
            .uri("/images/{id}/{width}/{height}", id, width, height)
            .retrieve()
            .body(byte[].class);
}

# Inside ForstifyClient - see GET /version for full class setup

def get_scaled_image(self, id: str, width: int, height: int) -> bytes:
    resp = self._session.get(f"{self.BASE_URL}/images/{id}/{width}/{height}")
    resp.raise_for_status()
    return resp.content

// Inside Client - see GET /version for full struct setup

func (c *Client) GetScaledImage(id string, width, height int) ([]byte, error) {
    path := fmt.Sprintf("/images/%s/%d/%d", id, width, height)
    req, _ := http.NewRequest(http.MethodGet, c.baseURL+path, nil)
    req.Header.Set("X-API-KEY", c.apiKey)

    resp, err := c.http.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("forstify: %s", resp.Status)
    }

    return io.ReadAll(resp.Body)
}