Recent Live Detail

GET /api/jkt48/recent/125100001751127046?apikey=YOUR_API_KEY HTTP/1.1
Host: v2.jkt48connect.my.id

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://v2.jkt48connect.my.id';

async function getStreamDetail(dataId) {
  try {
    const response = await fetch(
      `${BASE_URL}/api/jkt48/recent/${dataId}?apikey=${API_KEY}`
    );
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    
    const detail = await response.json();
    return detail;
  } catch (error) {
    console.error('Failed to fetch stream detail:', error);
    throw error;
  }
}

// Usage example
async function displayStreamDetails() {
  // First get recent streams
  const recentResponse = await fetch(`${BASE_URL}/api/jkt48/recent?apikey=${API_KEY}`);
  const recentStreams = await recentResponse.json();
  
  // Get detail for the first stream
  if (recentStreams.length > 0) {
    const dataId = recentStreams[0].data_id;
    const detail = await getStreamDetail(dataId);
    
    console.log('Stream Detail:', detail);
  }
}

import requests
import json

API_KEY = 'YOUR_API_KEY'
BASE_URL = 'https://v2.jkt48connect.my.id'

def get_stream_detail(data_id):
    """Get detailed information for a specific stream"""
    url = f"{BASE_URL}/api/jkt48/recent/{data_id}"
    params = {'apikey': API_KEY}
    
    try:
        response = requests.get(url, params=params)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error fetching stream detail: {e}")
        raise

def get_recent_with_details():
    """Get recent streams and their detailed information"""
    # Get recent streams first
    recent_response = requests.get(f"{BASE_URL}/api/jkt48/recent?apikey={API_KEY}")
    recent_streams = recent_response.json()
    
    detailed_streams = []
    for stream in recent_streams[:3]:  # Get details for first 3 streams
        data_id = stream['data_id']
        detail = get_stream_detail(data_id)
        detailed_streams.append({
            'basic_info': stream,
            'detailed_info': detail
        })
    
    return detailed_streams

# Usage
if __name__ == "__main__":
    try:
        streams_with_details = get_recent_with_details()
        print(json.dumps(streams_with_details, indent=2))
    except Exception as e:
        print(f"Error: {e}")

package main

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

const (
    APIKey  = "YOUR_API_KEY"
    BaseURL = "https://v2.jkt48connect.my.id"
)

type StreamDetail struct {
    // Define based on actual API response structure
    DataID string `json:"data_id"`
    // Add other fields as needed
}

type RecentStream struct {
    DataID string `json:"data_id"`
    Member struct {
        Nickname string `json:"nickname"`
    } `json:"member"`
}

func getStreamDetail(dataID string) (*StreamDetail, error) {
    url := fmt.Sprintf("%s/api/jkt48/recent/%s?apikey=%s", BaseURL, dataID, APIKey)
    
    client := &http.Client{Timeout: 10 * time.Second}
    resp, err := client.Get(url)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("API request failed with status: %d", resp.StatusCode)
    }
    
    var detail StreamDetail
    err = json.NewDecoder(resp.Body).Decode(&detail)
    return &detail, err
}

func getRecentStreams() ([]RecentStream, error) {
    url := fmt.Sprintf("%s/api/jkt48/recent?apikey=%s", BaseURL, APIKey)
    
    resp, err := http.Get(url)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    var streams []RecentStream
    err = json.NewDecoder(resp.Body).Decode(&streams)
    return streams, err
}

func main() {
    // Get recent streams
    streams, err := getRecentStreams()
    if err != nil {
        fmt.Printf("Error getting recent streams: %v\n", err)
        return
    }
    
    // Get detail for first stream
    if len(streams) > 0 {
        detail, err := getStreamDetail(streams[0].DataID)
        if err != nil {
            fmt.Printf("Error getting stream detail: %v\n", err)
            return
        }
        
        fmt.Printf("Stream detail for %s: %+v\n", streams[0].Member.Nickname, detail)
    }
}

async function fetchStreamDetailSafely(dataId) {
  const maxRetries = 3;
  let retryCount = 0;
  
  while (retryCount < maxRetries) {
    try {
      const response = await fetch(
        `${BASE_URL}/api/jkt48/recent/${dataId}?apikey=${API_KEY}`
      );
      
      if (response.status === 404) {
        throw new Error('Stream data not found');
      }
      
      if (response.status === 429) {
        // Wait before retrying
        await new Promise(resolve => setTimeout(resolve, 1000 * (retryCount + 1)));
        retryCount++;
        continue;
      }
      
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }
      
      return await response.json();
    } catch (error) {
      if (retryCount === maxRetries - 1) {
        throw error;
      }
      retryCount++;
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
  }
}