Newport Exchange API

curl -s "https://api.newportexchange.org/v2/posts?symbol=BTC&limit=5" \
  -H "X-API-Key: YOUR_API_KEY"

// quickstart.mjs — Node 18+ (global fetch). Run: node quickstart.mjs
const API_BASE = 'https://api.newportexchange.org/v2';
const API_KEY = process.env.NEX_API_KEY ?? 'YOUR_API_KEY';

const res = await fetch(`${API_BASE}/posts?symbol=BTC&limit=5`, {
  headers: { 'X-API-Key': API_KEY },
});
if (!res.ok) {
  const err = await res.json().catch(() => ({}));
  throw new Error(`HTTP ${res.status}: ${err.message ?? res.statusText}`);
}

const { data, meta } = await res.json();
for (const post of data) console.log(post.published_at, post.title);
console.log('More pages available:', meta.has_more);

# quickstart.py — Python 3.8+, pip install requests
import os

import requests

API_BASE = "https://api.newportexchange.org/v2"
API_KEY = os.environ.get("NEX_API_KEY", "YOUR_API_KEY")

resp = requests.get(
    f"{API_BASE}/posts",
    headers={"X-API-Key": API_KEY},
    params={"symbol": "BTC", "limit": 5},
    timeout=10,
)
resp.raise_for_status()
body = resp.json()

for post in body["data"]:
    print(post["published_at"], post["title"])
print("More pages available:", body["meta"]["has_more"])

curl -s -G "https://api.newportexchange.org/v2/posts" \
  -H "X-API-Key: YOUR_API_KEY" \
  --data-urlencode "q=etf" \
  --data-urlencode "symbol=BTC" \
  --data-urlencode "from=2026-09-01" \
  --data-urlencode "sort=newest" \
  --data-urlencode "limit=20" \
  --data-urlencode "page=1"

// Node 18+
const API_BASE = 'https://api.newportexchange.org/v2';
const API_KEY = process.env.NEX_API_KEY ?? 'YOUR_API_KEY';

const params = new URLSearchParams({
  q: 'etf',
  symbol: 'BTC',
  from: '2026-09-01',
  sort: 'newest',
  limit: '20',
  page: '1',
});

const res = await fetch(`${API_BASE}/posts?${params}`, {
  headers: { 'X-API-Key': API_KEY },
});
const body = await res.json();
if (!res.ok) throw new Error(`HTTP ${res.status}: ${body.message}`);

console.log(body.meta); // { page: 1, limit: 20, has_more: …, filters: { … } }
console.log(body.data.map((post) => post.title));

import os

import requests

API_BASE = "https://api.newportexchange.org/v2"
API_KEY = os.environ.get("NEX_API_KEY", "YOUR_API_KEY")

resp = requests.get(
    f"{API_BASE}/posts",
    headers={"X-API-Key": API_KEY},
    params={
        "q": "etf",
        "symbol": "BTC",
        "from": "2026-09-01",
        "sort": "newest",
        "limit": 20,
        "page": 1,
    },
    timeout=10,
)
body = resp.json()
if not resp.ok:
    raise RuntimeError(f"HTTP {resp.status_code}: {body.get('message')}")

print(body["meta"])
print([post["title"] for post in body["data"]])

curl -s "https://api.newportexchange.org/v2/posts/bitcoin-rallies-as-etf-inflows-accelerate" \
  -H "X-API-Key: YOUR_API_KEY"

// Node 18+
const API_BASE = 'https://api.newportexchange.org/v2';
const API_KEY = process.env.NEX_API_KEY ?? 'YOUR_API_KEY';

const slug = 'bitcoin-rallies-as-etf-inflows-accelerate';
const res = await fetch(`${API_BASE}/posts/${encodeURIComponent(slug)}`, {
  headers: { 'X-API-Key': API_KEY },
});

if (res.status === 404) {
  console.log('Post not found');
} else if (!res.ok) {
  throw new Error(`HTTP ${res.status}`);
} else {
  const { data: post } = await res.json();
  const paragraphs = post.body.split('\n\n');
  console.log(post.title, `(${paragraphs.length} paragraphs)`);
}

import os
from urllib.parse import quote

import requests

API_BASE = "https://api.newportexchange.org/v2"
API_KEY = os.environ.get("NEX_API_KEY", "YOUR_API_KEY")

slug = "bitcoin-rallies-as-etf-inflows-accelerate"
resp = requests.get(
    f"{API_BASE}/posts/{quote(slug)}",
    headers={"X-API-Key": API_KEY},
    timeout=10,
)

if resp.status_code == 404:
    print("Post not found")
else:
    resp.raise_for_status()
    post = resp.json()["data"]
    paragraphs = post["body"].split("\n\n")
    print(post["title"], f"({len(paragraphs)} paragraphs)")

curl -s "https://api.newportexchange.org/v2/crypto/currencies?rankFrom=1&rankTo=10"

// Node 18+ — public endpoint, no API key
const res = await fetch('https://api.newportexchange.org/v2/crypto/currencies?rankFrom=1&rankTo=10');
if (!res.ok) throw new Error(`HTTP ${res.status}`);

const coins = await res.json(); // bare array, ordered by rank
for (const coin of coins) {
  console.log(coin.rank, coin.symbol, Number(coin.price_usd).toFixed(2));
}

import requests

resp = requests.get(
    "https://api.newportexchange.org/v2/crypto/currencies",
    params={"rankFrom": 1, "rankTo": 10},
    timeout=10,
)
resp.raise_for_status()

for coin in resp.json():  # bare list, ordered by rank
    print(coin["rank"], coin["symbol"], round(coin["price_usd"], 2))

curl -s "https://api.newportexchange.org/v2/crypto/BTC"

// Node 18+ — public endpoint, no API key
const res = await fetch('https://api.newportexchange.org/v2/crypto/BTC');
if (res.status === 404) throw new Error('Unknown symbol');
if (!res.ok) throw new Error(`HTTP ${res.status}`);

const btc = await res.json(); // a single object, not wrapped in "data"
console.log(btc.name, btc.price_usd, btc.percent_change_day);

import requests

resp = requests.get("https://api.newportexchange.org/v2/crypto/BTC", timeout=10)
if resp.status_code == 404:
    raise SystemExit("Unknown symbol")
resp.raise_for_status()

btc = resp.json()  # a single object, not wrapped in "data"
print(btc["name"], btc["price_usd"], btc["percent_change_day"])

curl -s "https://api.newportexchange.org/v2/crypto/historical/BTC?days=30"

// Node 18+ — public endpoint, no API key
const res = await fetch('https://api.newportexchange.org/v2/crypto/historical/BTC?days=30');
if (!res.ok) throw new Error(`HTTP ${res.status}`);

const candles = await res.json(); // newest first
for (const c of candles) {
  console.log(new Date(c.time * 1000).toISOString().slice(0, 10), c.close);
}

from datetime import datetime, timezone

import requests

resp = requests.get("https://api.newportexchange.org/v2/crypto/historical/BTC", params={"days": 30}, timeout=10)
resp.raise_for_status()

for c in resp.json():  # newest first
    day = datetime.fromtimestamp(c["time"], tz=timezone.utc).date()
    print(day, c["close"])

curl -s "https://api.newportexchange.org/v2/crypto-history/ETH?from=2026-09-01&to=2026-09-26"

// Node 18+ — public endpoint, no API key
const params = new URLSearchParams({ from: '2026-09-01', to: '2026-09-26' });
const res = await fetch(`https://api.newportexchange.org/v2/crypto-history/ETH?${params}`);
if (!res.ok) throw new Error(`HTTP ${res.status}`);

const candles = await res.json(); // oldest first
console.log(candles.length, 'daily candles');

import requests

resp = requests.get(
    "https://api.newportexchange.org/v2/crypto-history/ETH",
    params={"from": "2026-09-01", "to": "2026-09-26"},
    timeout=10,
)
resp.raise_for_status()

candles = resp.json()  # oldest first
print(len(candles), "daily candles")

curl -s -i "https://api.newportexchange.org/v2/news?q=ethereum&limit=10&page=1"

// Node 18+ — public endpoint, no API key
const res = await fetch('https://api.newportexchange.org/v2/news?q=ethereum&limit=10&page=1');
if (!res.ok) throw new Error(`HTTP ${res.status}`);

const articles = await res.json(); // bare array, newest first
console.log('page', res.headers.get('X-Page'), 'of size', res.headers.get('X-Per-Page'));
for (const a of articles) {
  console.log(new Date(a.publishedAt * 1000).toISOString(), a.title);
}

from datetime import datetime, timezone

import requests

resp = requests.get(
    "https://api.newportexchange.org/v2/news",
    params={"q": "ethereum", "limit": 10, "page": 1},
    timeout=10,
)
resp.raise_for_status()

for a in resp.json():  # bare list, newest first
    published = datetime.fromtimestamp(a["publishedAt"], tz=timezone.utc)
    print(published.isoformat(), a["title"])

curl -s "https://api.newportexchange.org/v2/news/ethereum-developers-set-date-next-network-upgrade"

// Node 18+ — public endpoint, no API key
const alias = 'ethereum-developers-set-date-next-network-upgrade';
const res = await fetch(`https://api.newportexchange.org/v2/news/${encodeURIComponent(alias)}`);
if (res.status === 404) throw new Error('News item not found');
if (!res.ok) throw new Error(`HTTP ${res.status}`);

const article = await res.json(); // full description, not an excerpt
console.log(article.title);

import requests

alias = "ethereum-developers-set-date-next-network-upgrade"
resp = requests.get(f"https://api.newportexchange.org/v2/news/{alias}", timeout=10)
if resp.status_code == 404:
    raise SystemExit("News item not found")
resp.raise_for_status()

article = resp.json()  # full description, not an excerpt
print(article["title"])

# One polling step: everything published at or after a stored cursor
# (unix seconds), oldest first, so pages stay stable while new posts arrive.
SINCE=1758808980   # published_at of the newest post you have already processed

curl -s -G "https://api.newportexchange.org/v2/posts" \
  -H "X-API-Key: YOUR_API_KEY" \
  --data-urlencode "from=$SINCE" \
  --data-urlencode "sort=oldest" \
  --data-urlencode "limit=100" \
  --data-urlencode "page=1"
# Repeat with page=2, 3, … while meta.has_more is true.
# Skip ids you have already processed: `from` is inclusive of the boundary.

// poll-posts.mjs — Node 18+. Fetches posts published since the last run.
// Schedule it (cron, a worker loop) no more often than once a minute.
import { readFile, writeFile } from 'node:fs/promises';

const API_BASE = 'https://api.newportexchange.org/v2';
const API_KEY = process.env.NEX_API_KEY ?? 'YOUR_API_KEY';
const STATE_FILE = './posts-cursor.json';
const MAX_RETRIES = 5;

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
const toUnix = (iso) => Math.floor(Date.parse(iso) / 1000);

async function getJson(path, params) {
  for (let attempt = 0; ; attempt += 1) {
    const res = await fetch(`${API_BASE}${path}?${new URLSearchParams(params)}`, {
      headers: { 'X-API-Key': API_KEY },
    });

    const retryable = res.status === 429 || res.status >= 500;
    if (retryable && attempt < MAX_RETRIES) {
      // Wait for the rate-limit window to reset, or exponential backoff —
      // whichever is longer — plus random jitter so clients don't sync up.
      const resetSeconds = Number(res.headers.get('RateLimit-Reset'));
      const backoffMs = Math.min(60_000, 1000 * 2 ** attempt);
      const resetMs = Number.isFinite(resetSeconds) ? resetSeconds * 1000 : 0;
      await sleep(Math.max(resetMs, backoffMs) + Math.random() * 1000);
      continue;
    }

    const body = await res.json().catch(() => ({}));
    if (!res.ok) throw new Error(`HTTP ${res.status}: ${body.message ?? res.statusText}`);
    return body;
  }
}

async function loadCursor() {
  try {
    return JSON.parse(await readFile(STATE_FILE, 'utf8'));
  } catch {
    // First run: start from 24 hours ago rather than paging the whole archive.
    return { since: Math.floor(Date.now() / 1000) - 86_400, seenIds: [] };
  }
}

export async function pollNewPosts(handlePost) {
  const cursor = await loadCursor();
  const seen = new Set(cursor.seenIds);
  const fresh = [];

  for (let page = 1; ; page += 1) {
    const { data, meta } = await getJson('/posts', {
      from: String(cursor.since),
      sort: 'oldest',
      limit: '100',
      page: String(page),
    });
    for (const post of data) if (!seen.has(post.id)) fresh.push(post);
    if (!meta.has_more) break;
  }

  for (const post of fresh) await handlePost(post);

  // Persist the cursor only after the posts were handled, so a crash replays
  // them instead of skipping them. Remember the ids sitting exactly on the
  // boundary second, because `from` includes that second on the next run.
  if (fresh.length > 0) {
    const newest = Math.max(...fresh.map((p) => toUnix(p.published_at)));
    const boundaryIds = fresh.filter((p) => toUnix(p.published_at) === newest).map((p) => p.id);
    const seenIds = newest === cursor.since ? [...cursor.seenIds, ...boundaryIds] : boundaryIds;
    await writeFile(STATE_FILE, JSON.stringify({ since: newest, seenIds }));
  }
  return fresh.length;
}

const count = await pollNewPosts(async (post) => {
  console.log(post.published_at, post.source, post.title);
});
console.log(`${count} new post(s)`);

"""poll_posts.py — fetch posts published since the last run.

Python 3.8+, pip install requests. Schedule it no more often than once a minute.
"""
import json
import os
import random
import time
from datetime import datetime, timedelta, timezone
from pathlib import Path

import requests

API_BASE = "https://api.newportexchange.org/v2"
API_KEY = os.environ.get("NEX_API_KEY", "YOUR_API_KEY")
STATE_FILE = Path("posts-cursor.json")
MAX_RETRIES = 5

session = requests.Session()
session.headers["X-API-Key"] = API_KEY


def get_json(path, params):
    for attempt in range(MAX_RETRIES + 1):
        resp = session.get(f"{API_BASE}{path}", params=params, timeout=15)
        retryable = resp.status_code == 429 or resp.status_code >= 500
        if retryable and attempt < MAX_RETRIES:
            # Wait for the rate-limit window to reset, or exponential backoff,
            # whichever is longer, plus random jitter.
            reset = resp.headers.get("RateLimit-Reset", "")
            reset_seconds = int(reset) if reset.isdigit() else 0
            backoff = min(60, 2 ** attempt)
            time.sleep(max(reset_seconds, backoff) + random.uniform(0, 1))
            continue
        resp.raise_for_status()
        return resp.json()


def to_unix(iso):
    return int(datetime.fromisoformat(iso.replace("Z", "+00:00")).timestamp())


def load_cursor():
    if STATE_FILE.exists():
        return json.loads(STATE_FILE.read_text())
    # First run: start from 24 hours ago rather than paging the whole archive.
    day_ago = datetime.now(timezone.utc) - timedelta(days=1)
    return {"since": int(day_ago.timestamp()), "seen_ids": []}


def poll_new_posts(handle_post):
    cursor = load_cursor()
    seen = set(cursor["seen_ids"])
    fresh = []

    page = 1
    while True:
        body = get_json(
            "/posts",
            {"from": cursor["since"], "sort": "oldest", "limit": 100, "page": page},
        )
        fresh.extend(p for p in body["data"] if p["id"] not in seen)
        if not body["meta"]["has_more"]:
            break
        page += 1

    for post in fresh:
        handle_post(post)

    # Persist only after handling, so a crash replays rather than skips.
    # Keep the ids on the boundary second: `from` includes it next time.
    if fresh:
        newest = max(to_unix(p["published_at"]) for p in fresh)
        boundary = [p["id"] for p in fresh if to_unix(p["published_at"]) == newest]
        seen_ids = cursor["seen_ids"] + boundary if newest == cursor["since"] else boundary
        STATE_FILE.write_text(json.dumps({"since": newest, "seen_ids": seen_ids}))
    return len(fresh)


if __name__ == "__main__":
    count = poll_new_posts(lambda p: print(p["published_at"], p["source"], p["title"]))
    print(f"{count} new post(s)")