Sports Picks API Quickstart for Node.js and Python

STEP 01 / SECURITY

1. Store the API key on your server

PowerHouse issues a revocable credential during technical onboarding. Store it in your deployment platform’s encrypted secret manager and expose it only to the server process making the request. Never place it in browser JavaScript, a mobile bundle, analytics, logs, screenshots, tickets, or a public repository.

POWERHOUSE_API_KEY=ph_live_YOUR_KEY

STEP 02 / cURL

2. Make your first cURL request

Request a small upcoming page first. The sport value must match an entitled sport, and the response can contain fewer records than the requested limit when licence or quality gates exclude source rows.

export POWERHOUSE_API_KEY="ph_live_YOUR_KEY"

curl --fail-with-body \
  --header "Authorization: Bearer ${POWERHOUSE_API_KEY}" \
  --header "Accept: application/json" \
  "https://www.powerhouseaffiliates.com/api/v1/picks?sport=Soccer&status=upcoming&limit=10"

A successful response returns data, page.nextCursor, page.hasMore, and a requestId. Keep the request ID with operational logs; it is the safest reference when investigating a delivery.

STEP 03 / NODE.JS

3. Connect with Node.js

This example uses the native fetch implementation available in current Node.js releases, so it needs no HTTP client dependency. Run it in a server process, background job, or protected function—not a Client Component.

const apiKey = process.env.POWERHOUSE_API_KEY;

if (!apiKey) throw new Error("POWERHOUSE_API_KEY is required");

const url = new URL(
  "https://www.powerhouseaffiliates.com/api/v1/picks"
);
url.search = new URLSearchParams({
  sport: "Soccer",
  status: "upcoming",
  limit: "10",
}).toString();

const response = await fetch(url, {
  headers: {
    Accept: "application/json",
    Authorization: `Bearer ${apiKey}`,
  },
});

const body = await response.json();
if (!response.ok) {
  throw new Error(
    `${body.error?.code ?? response.status}: ${body.error?.message}`
  );
}

console.log(body.data);
console.log("Request ID:", body.requestId);

Do not log the complete request headers. Log the returned request ID, response status, route, record count, and elapsed time instead. Treat every response as private customer data and apply the retention rules in the active licence.

STEP 04 / PYTHON

4. Connect with Python

The Python example uses requests, an explicit timeout, and the same response contract as Node.js. Install the dependency with python -m pip install requests.

import os
import requests

api_key = os.environ["POWERHOUSE_API_KEY"]
response = requests.get(
    "https://www.powerhouseaffiliates.com/api/v1/picks",
    headers={
        "Accept": "application/json",
        "Authorization": f"Bearer {api_key}",
    },
    params={
        "sport": "Soccer",
        "status": "upcoming",
        "limit": 10,
    },
    timeout=15,
)

body = response.json()
if not response.ok:
    error = body.get("error", {})
    raise RuntimeError(
        f"{error.get('code', response.status_code)}: "
        f"{error.get('message', 'Request failed')}"
    )

print(body["data"])
print("Request ID:", body["requestId"])

In production, reuse a requests.Session, set a bounded retry policy for transient failures, and send the key through the Authorization header on every request. Never place the key in the query string.

STEP 05 / PAGINATION

5. Follow cursor pagination

List routes cap each page at 200 records. Continue while page.nextCursor is non-null. A cursor is opaque: store or forward it unchanged, do not decode it, and do not assume it remains valid after changing filters.

let cursor;

do {
  const url = new URL(
    "https://www.powerhouseaffiliates.com/api/v1/picks"
  );
  url.searchParams.set("limit", "200");
  if (cursor) url.searchParams.set("cursor", cursor);

  const response = await fetch(url, {
    headers: { Authorization: `Bearer ${process.env.POWERHOUSE_API_KEY}` },
  });
  const body = await response.json();
  if (!response.ok) throw new Error(body.error?.message);

  await publishLicensedRecords(body.data);
  cursor = body.page.nextCursor;
} while (cursor);

Process each page idempotently using the stable record id. If a job fails after publication but before checkpointing the cursor, replaying the page should update the same records rather than create duplicates.

STEP 06 / OPERATIONS

6. Handle lifecycle and errors

Sports intelligence changes state after initial publication. Consumers should reconcile status, result, settledAt, and publishedAt against the stable ID. Never infer settlement from the event date alone.

{
  "error": {
    "code": "INVALID_FILTERS",
    "message": "One or more filters are invalid",
    "requestId": "req_..."
  }
}

Error and success responses include a request ID. Retry only transient conditions, cap the number of attempts, add jitter, and surface persistent delivery failures to an operator.

PRODUCTION CHECKLIST

Move from a successful request to a reliable product.

• Keep credentials server-only and rotate them after exposure.
• Validate responses against the published JSON Schema.
• Use stable IDs for idempotent upserts and corrections.
• Persist request IDs without persisting bearer credentials.
• Respect licensed sports, channels, fields, and retention.
• Test 400, 401, 403, 404, 429, and 503 behavior.
• Agree polling cadence and operational ownership during the pilot.

Availability is subject to schedule, market availability, model quality gates, and the customer licence. The API delivers structured sports intelligence; it does not guarantee inventory volume or sporting outcomes.