LunarFeed API Documentation

curl -X GET "https://api.lunarfeed.online/api/v1/crypto/articles/translated/?lang=en&limit=5&direction=newer" \
  -H "X-API-Key: your_api_key_here" \
  -H "Accept: application/json"

const response = await fetch(
  'https://api.lunarfeed.online/api/v1/crypto/articles/translated/?lang=en&limit=10&direction=newer',
  {
    headers: {
      'X-API-Key': 'your_api_key_here',
      'Accept': 'application/json'
    }
  }
);

const articles = await response.json();

import requests

API_KEY = "your_api_key_here"
BASE_URL = "https://api.lunarfeed.online/api/v1/crypto/articles/translated/"

def fetch_newer(limit=10):
    response = requests.get(BASE_URL, headers={
        "X-API-Key": API_KEY,
        "Accept": "application/json"
    }, params={
        "limit": limit,
        "direction": "newer"
    })

    response.raise_for_status()
    articles = response.json()

    if not articles:
        print("No new articles available.")
    else:
        print(f"Fetched {len(articles)} newer articles.")

    return articles

def fetch_older(limit=10):
    response = requests.get(BASE_URL, headers={
        "X-API-Key": API_KEY,
        "Accept": "application/json"
    }, params={
        "limit": limit,
        "direction": "older"
    })

    response.raise_for_status()
    articles = response.json()

    if not articles:
        print("No more historical articles.")
    else:
        print(f"Fetched {len(articles)} older articles.")

    return articles

curl -X GET "https://api.lunarfeed.online/api/v1/crypto/articles/translated/latest-snapshot/?lang=en&limit=10" \
  -H "X-API-Key: your_api_key_here" \
  -H "Accept: application/json"

// Real-time polling example
const pollSnapshots = async () => {
  try {
    const response = await fetch(
      'https://api.lunarfeed.online/api/v1/crypto/articles/translated/latest-snapshot/?lang=en&limit=20',
      {
        headers: {
          'X-API-Key': 'your_api_key_here',
          'Accept': 'application/json'
        }
      }
    );
    
    const articles = await response.json();
    console.log(`Received ${articles.length} articles`);
    
    // Process articles for your system
    processArticles(articles);
    
  } catch (error) {
    console.error('Snapshot polling failed:', error);
  }
};

// Poll every 5 minutes
setInterval(pollSnapshots, 5 * 60 * 1000);

import requests
import time

def fetch_snapshot(lang='en', limit=20):
    headers = {
        "X-API-Key": "your_api_key_here",
        "Accept": "application/json"
    }
    
    params = {
        "lang": lang,
        "limit": limit
    }
    
    response = requests.get(
        "https://api.lunarfeed.online/api/v1/crypto/articles/translated/latest-snapshot/",
        headers=headers,
        params=params
    )
    
    return response.json()

# Real-time ingestion loop
while True:
    try:
        articles = fetch_snapshot()
        print(f"Ingested {len(articles)} articles")
        
        # Process articles for your system
        process_articles(articles)
        
        # Wait 5 minutes before next poll
        time.sleep(300)
        
    except Exception as e:
        print(f"Error: {e}")
        time.sleep(60)  # Wait 1 minute on error

import requests

def fetch_articles(api_key: str, lang: str = 'en', limit: int = 10):
    """
    Fetch translated cryptocurrency articles from LunarFeed API.

    Args:
        api_key (str): Your LunarFeed API key.
        lang (str): Target language for translation (default: 'en').
        limit (int): Number of articles to fetch (default: 10).

    Returns:
        list: List of translated article objects.

    Raises:
        Exception: If the request fails or the API returns an error.
    """
    url = "https://api.lunarfeed.online/api/v1/crypto/articles/translated/"
    headers = {
        "X-API-Key": api_key,
        "Accept": "application/json"
    }
    params = {
        "lang": lang,
        "limit": limit
    }

    try:
        response = requests.get(url, headers=headers, params=params)

        # Check for HTTP errors
        if response.status_code != 200:
            try:
                error_data = response.json()
                detail = error_data.get("detail", "Unknown error")
                raise Exception(f"Error {response.status_code}: {detail}")
            except ValueError:
                raise Exception(f"Error {response.status_code}: Unable to parse error response")

        # Return parsed JSON data
        return response.json()

    except requests.exceptions.RequestException as e:
        raise Exception(f"Request failed: {str(e)}")

class LunarFeedCache {
  constructor(ttl = 300000) { // 5 minutes default TTL
    this.cache = new Map();
    this.ttl = ttl;
  }
  
  set(key, value) {
    this.cache.set(key, {
      value,
      timestamp: Date.now()
    });
  }
  
  get(key) {
    const item = this.cache.get(key);
    if (!item) return null;
    
    if (Date.now() - item.timestamp > this.ttl) {
      this.cache.delete(key);
      return null;
    }
    
    return item.value;
  }
  
  clear() {
    this.cache.clear();
  }
}

class OptimizedLunarFeedClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.cache = new LunarFeedCache();
    this.requestQueue = [];
    this.processing = false;
  }
  
  async getArticles(params = {}) {
    const cacheKey = JSON.stringify(params);
    const cached = this.cache.get(cacheKey);
    
    if (cached) {
      console.log('Returning cached result');
      return cached;
    }
    
    const articles = await this.fetchArticles(params);
    this.cache.set(cacheKey, articles);
    
    return articles;
  }
  
  async fetchArticles(params) {
    const queryString = new URLSearchParams(params).toString();
    const response = await fetch(
      `https://api.lunarfeed.online/api/v1/crypto/articles/translated/?${queryString}`,
      {
        headers: {
          'X-API-Key': this.apiKey,
          'Accept': 'application/json',
          'Accept-Encoding': 'gzip'
        }
      }
    );
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    
    return await response.json();
  }
}

import requests
import time
import json
from typing import Optional

class LunarFeedCache:
    def __init__(self, ttl: int = 300):  # Default TTL: 5 minutes (in seconds)
        self.cache = {}
        self.ttl = ttl

    def set(self, key: str, value: dict):
        self.cache[key] = {
            'value': value,
            'timestamp': time.time()
        }

    def get(self, key: str) -> Optional[dict]:
        item = self.cache.get(key)
        if not item:
            return None
        
        if time.time() - item['timestamp'] > self.ttl:
            del self.cache[key]
            return None

        return item['value']

    def clear(self):
        self.cache.clear()


class OptimizedLunarFeedClient:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.cache = LunarFeedCache()
        self.base_url = "https://api.lunarfeed.online"

    def get_articles(self, lang: str = "en", limit: int = 10, direction: str = "newer"):
        params = {
            "lang": lang,
            "limit": limit,
            "direction": direction
        }

        cache_key = json.dumps(params, sort_keys=True)
        cached = self.cache.get(cache_key)
        if cached:
            print("🔁 Returning cached result")
            return cached

        url = f"{self.base_url}/api/v1/crypto/articles/translated/"
        headers = {
            "X-API-Key": self.api_key,
            "Accept": "application/json",
            "Accept-Encoding": "gzip"
        }

        response = requests.get(url, headers=headers, params=params)

        if response.status_code != 200:
            raise Exception(f"HTTP {response.status_code}: {response.text}")

        data = response.json()
        self.cache.set(cache_key, data)
        return data


# Usage Example
client = OptimizedLunarFeedClient("your_api_key_here")
try:
    articles = client.get_articles(lang="en", limit=5)
    print(f"✅ Fetched {len(articles)} articles")
except Exception as e:
    print(f"❌ Error: {e}")

class RateLimitedClient {
  constructor(apiKey, requestsPerMinute = 60) {
    this.apiKey = apiKey;
    this.requestsPerMinute = requestsPerMinute;
    this.requestTimes = [];
  }
  
  async makeRequest(url, options = {}) {
    await this.waitForRateLimit();
    
    const response = await fetch(url, {
      ...options,
      headers: {
        'X-API-Key': this.apiKey,
        'Accept': 'application/json',
        ...options.headers
      }
    });
    
    this.requestTimes.push(Date.now());
    
    if (response.status === 429) {
      const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
      console.log(`Rate limited. Waiting ${retryAfter} seconds...`);
      await this.sleep(retryAfter * 1000);
      return this.makeRequest(url, options); // Retry
    }
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    
    return response.json();
  }
  
  async waitForRateLimit() {
    const now = Date.now();
    const oneMinuteAgo = now - 60000;
    
    // Remove old requests
    this.requestTimes = this.requestTimes.filter(time => time > oneMinuteAgo);
    
    if (this.requestTimes.length >= this.requestsPerMinute) {
      const oldestRequest = this.requestTimes[0];
      const waitTime = 60000 - (now - oldestRequest);
      
      if (waitTime > 0) {
        console.log(`Rate limit reached. Waiting ${waitTime}ms...`);
        await this.sleep(waitTime);
      }
    }
  }
  
  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

import time
import requests
from collections import deque
from typing import Optional

class RateLimitedClient:
    def __init__(self, api_key: str, requests_per_minute: int = 60):
        self.api_key = api_key
        self.requests_per_minute = requests_per_minute
        self.request_times = deque()

    def _wait_for_rate_limit(self):
        now = time.time()
        one_minute_ago = now - 60

        # Remove outdated timestamps
        while self.request_times and self.request_times[0] < one_minute_ago:
            self.request_times.popleft()

        if len(self.request_times) >= self.requests_per_minute:
            oldest = self.request_times[0]
            wait_time = 60 - (now - oldest)
            if wait_time > 0:
                print(f"⏳ Rate limit reached. Waiting {int(wait_time)} seconds...")
                time.sleep(wait_time)

    def make_request(self, url: str, params: Optional[dict] = None) -> dict:
        self._wait_for_rate_limit()

        headers = {
            "X-API-Key": self.api_key,
            "Accept": "application/json"
        }

        try:
            response = requests.get(url, headers=headers, params=params)
            self.request_times.append(time.time())

            if response.status_code == 429:
                retry_after = int(response.headers.get("Retry-After", 60))
                print(f"🚫 Rate limited. Retrying in {retry_after} seconds...")
                time.sleep(retry_after)
                return self.make_request(url, params)  # Retry

            response.raise_for_status()
            return response.json()

        except requests.RequestException as e:
            print(f"❌ Request failed: {e}")
            raise

# Usage Example
if __name__ == "__main__":
    client = RateLimitedClient("your_api_key_here", requests_per_minute=60)
    
    try:
        result = client.make_request(
            "https://api.lunarfeed.online/api/v1/crypto/articles/translated/",
            params={"lang": "en", "limit": 5}
        )
        print(f"✅ Fetched {len(result)} articles")
    except Exception as e:
        print(f"❌ Error: {e}")