All Live

// Using Fetch API
const API_KEY = 'YOUR_API_KEY'; // Get your API key from https://www.jkt48connect.my.id/buyapi
const BASE_URL = 'https://v2.jkt48connect.my.id';
const ENDPOINT = '/api/jkt48/live';

async function getAllLiveMembers() {
  try {
    const response = await fetch(`${BASE_URL}${ENDPOINT}?apikey=${API_KEY}`);
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const data = await response.json();
    console.log('Live members across all platforms:', data);
    
    // Process data by platform
    const platforms = {};
    data.forEach(member => {
      if (!platforms[member.type]) {
        platforms[member.type] = [];
      }
      platforms[member.type].push(member);
    });
    
    console.log('Members by platform:', platforms);
    return data;
  } catch (error) {
    console.error('Error fetching live members:', error);
  }
}

// Usage
getAllLiveMembers();

import requests
import json
from datetime import datetime

API_KEY = 'YOUR_API_KEY'  # Get your API key from https://www.jkt48connect.my.id/buyapi
BASE_URL = 'https://v2.jkt48connect.my.id'
ENDPOINT = '/api/jkt48/live'

def get_all_live_members():
    try:
        response = requests.get(f"{BASE_URL}{ENDPOINT}?apikey={API_KEY}")
        response.raise_for_status()  # Raise an exception for HTTP errors
        
        data = response.json()
        print(f"Found {len(data)} live members across all platforms")
        
        # Group by platform
        platforms = {}
        for member in data:
            platform = member['type']
            if platform not in platforms:
                platforms[platform] = []
            platforms[platform].append(member)
        
        # Display summary
        for platform, members in platforms.items():
            print(f"{platform.upper()}: {len(members)} members live")
            for member in members:
                started_time = datetime.fromisoformat(member['started_at'].replace('Z', '+00:00'))
                print(f"  - {member['name']} (started: {started_time.strftime('%H:%M:%S')})")
        
        return data
        
    except requests.exceptions.RequestException as e:
        print(f"Error fetching live members: {e}")
        return None

if __name__ == "__main__":
    get_all_live_members()

<?php
$apiKey = 'YOUR_API_KEY'; // Get your API key from https://www.jkt48connect.my.id/buyapi
$baseUrl = 'https://v2.jkt48connect.my.id';
$endpoint = '/api/jkt48/live';
$url = "{$baseUrl}{$endpoint}?apikey={$apiKey}";

function getAllLiveMembers($url) {
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_TIMEOUT, 30);
    
    $response = curl_exec($ch);
    
    if (curl_errno($ch)) {
        echo 'Error fetching live members: ' . curl_error($ch);
        curl_close($ch);
        return false;
    }
    
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode !== 200) {
        echo "HTTP Error: {$httpCode}";
        return false;
    }
    
    $data = json_decode($response, true);
    
    if (json_last_error() !== JSON_ERROR_NONE) {
        echo 'JSON Error: ' . json_last_error_msg();
        return false;
    }
    
    // Group by platform
    $platforms = [];
    foreach ($data as $member) {
        $platform = $member['type'];
        if (!isset($platforms[$platform])) {
            $platforms[$platform] = [];
        }
        $platforms[$platform][] = $member;
    }
    
    // Display results
    echo "Live members across all platforms:\n";
    foreach ($platforms as $platform => $members) {
        echo strtoupper($platform) . ": " . count($members) . " members\n";
        foreach ($members as $member) {
            $startedTime = date('H:i:s', strtotime($member['started_at']));
            echo "  - {$member['name']} (started: {$startedTime})\n";
        }
    }
    
    return $data;
}

getAllLiveMembers($url);
?>

package main

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

const (
    apiKey  = "YOUR_API_KEY" // Get your API key from https://www.jkt48connect.my.id/buyapi
    baseURL = "https://v2.jkt48connect.my.id"
    endpoint = "/api/jkt48/live"
)

type StreamingURL struct {
    Label   string `json:"label"`
    Quality int    `json:"quality"`
    URL     string `json:"url"`
}

type LiveMember struct {
    Name             string         `json:"name"`
    Img              string         `json:"img"`
    ImgAlt           string         `json:"img_alt"`
    URLKey           string         `json:"url_key"`
    Slug             string         `json:"slug"`
    RoomID           int            `json:"room_id"`
    IsGraduate       bool           `json:"is_graduate"`
    IsGroup          bool           `json:"is_group"`
    ChatRoomID       string         `json:"chat_room_id"`
    StartedAt        string         `json:"started_at"`
    StreamingURLList []StreamingURL `json:"streaming_url_list"`
    Type             string         `json:"type"`
}

func getAllLiveMembers() ([]LiveMember, error) {
    url := fmt.Sprintf("%s%s?apikey=%s", baseURL, endpoint, apiKey)
    
    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Get(url)
    if err != nil {
        return nil, fmt.Errorf("error making request: %v", err)
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("HTTP error: %d %s", resp.StatusCode, resp.Status)
    }
    
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("error reading response: %v", err)
    }
    
    var liveMembers []LiveMember
    err = json.Unmarshal(body, &liveMembers)
    if err != nil {
        return nil, fmt.Errorf("error parsing JSON: %v", err)
    }
    
    return liveMembers, nil
}

func main() {
    members, err := getAllLiveMembers()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    
    // Group by platform
    platforms := make(map[string][]LiveMember)
    for _, member := range members {
        platforms[member.Type] = append(platforms[member.Type], member)
    }
    
    fmt.Printf("Found %d live members across all platforms:\n", len(members))
    for platform, platformMembers := range platforms {
        fmt.Printf("%s: %d members\n", platform, len(platformMembers))
        for _, member := range platformMembers {
            startedAt, _ := time.Parse(time.RFC3339, member.StartedAt)
            fmt.Printf("  - %s (started: %s)\n", member.Name, startedAt.Format("15:04:05"))
        }
    }
}

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.time.Instant;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;

public class JKT48LiveAPI {
    private static final String API_KEY = "YOUR_API_KEY"; // Get your API key from https://www.jkt48connect.my.id/buyapi
    private static final String BASE_URL = "https://v2.jkt48connect.my.id";
    private static final String ENDPOINT = "/api/jkt48/live";
    
    public static class LiveMember {
        public String name;
        public String img;
        public String img_alt;
        public String url_key;
        public String slug;
        public int room_id;
        public boolean is_graduate;
        public boolean is_group;
        public String chat_room_id;
        public String started_at;
        public List<StreamingURL> streaming_url_list;
        public String type;
    }
    
    public static class StreamingURL {
        public String label;
        public int quality;
        public String url;
    }
    
    public static void main(String[] args) {
        try {
            List<LiveMember> members = getAllLiveMembers();
            
            // Group by platform
            Map<String, List<LiveMember>> platforms = new HashMap<>();
            for (LiveMember member : members) {
                platforms.computeIfAbsent(member.type, k -> new ArrayList<>()).add(member);
            }
            
            System.out.println("Found " + members.size() + " live members across all platforms:");
            for (Map.Entry<String, List<LiveMember>> entry : platforms.entrySet()) {
                String platform = entry.getKey();
                List<LiveMember> platformMembers = entry.getValue();
                
                System.out.println(platform.toUpperCase() + ": " + platformMembers.size() + " members");
                for (LiveMember member : platformMembers) {
                    Instant startedTime = Instant.parse(member.started_at);
                    String formattedTime = DateTimeFormatter.ofPattern("HH:mm:ss")
                        .withZone(ZoneId.systemDefault())
                        .format(startedTime);
                    System.out.println("  - " + member.name + " (started: " + formattedTime + ")");
                }
            }
            
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
    
    private static List<LiveMember> getAllLiveMembers() throws IOException, InterruptedException {
        String url = BASE_URL + ENDPOINT + "?apikey=" + API_KEY;
        
        HttpClient client = HttpClient.newBuilder()
            .timeout(Duration.ofSeconds(30))
            .build();
            
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .GET()
            .build();
            
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        
        if (response.statusCode() != 200) {
            throw new IOException("HTTP error: " + response.statusCode());
        }
        
        ObjectMapper mapper = new ObjectMapper();
        JsonNode jsonNode = mapper.readTree(response.body());
        
        List<LiveMember> members = new ArrayList<>();
        for (JsonNode node : jsonNode) {
            LiveMember member = mapper.treeToValue(node, LiveMember.class);
            members.add(member);
        }
        
        return members;
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;

public class JKT48LiveAPI
{
    private const string ApiKey = "YOUR_API_KEY"; // Get your API key from https://www.jkt48connect.my.id/buyapi
    private const string BaseUrl = "https://v2.jkt48connect.my.id";
    private const string Endpoint = "/api/jkt48/live";
    
    public class StreamingUrl
    {
        public string label { get; set; }
        public int quality { get; set; }
        public string url { get; set; }
    }
    
    public class LiveMember
    {
        public string name { get; set; }
        public string img { get; set; }
        public string img_alt { get; set; }
        public string url_key { get; set; }
        public string slug { get; set; }
        public int room_id { get; set; }
        public bool is_graduate { get; set; }
        public bool is_group { get; set; }
        public string chat_room_id { get; set; }
        public string started_at { get; set; }
        public List<StreamingUrl> streaming_url_list { get; set; }
        public string type { get; set; }
    }
    
    private static readonly HttpClient httpClient = new HttpClient();
    
    public static async Task Main(string[] args)
    {
        try
        {
            var members = await GetAllLiveMembersAsync();
            
            // Group by platform
            var platforms = members.GroupBy(m => m.type)
                                 .ToDictionary(g => g.Key, g => g.ToList());
            
            Console.WriteLine($"Found {members.Count} live members across all platforms:");
            
            foreach (var platform in platforms)
            {
                Console.WriteLine($"{platform.Key.ToUpper()}: {platform.Value.Count} members");
                
                foreach (var member in platform.Value)
                {
                    if (DateTime.TryParse(member.started_at, out DateTime startedTime))
                    {
                        Console.WriteLine($"  - {member.name} (started: {startedTime:HH:mm:ss})");
                    }
                    else
                    {
                        Console.WriteLine($"  - {member.name}");
                    }
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
    
    private static async Task<List<LiveMember>> GetAllLiveMembersAsync()
    {
        string url = $"{BaseUrl}{Endpoint}?apikey={ApiKey}";
        
        try
        {
            HttpResponseMessage response = await httpClient.GetAsync(url);
            response.EnsureSuccessStatusCode();
            
            string responseBody = await response.Content.ReadAsStringAsync();
            
            var options = new JsonSerializerOptions
            {
                PropertyNameCaseInsensitive = true
            };
            
            var members = JsonSerializer.Deserialize<List<LiveMember>>(responseBody, options);
            return members ?? new List<LiveMember>();
        }
        catch (HttpRequestException ex)
        {
            throw new Exception($"HTTP request failed: {ex.Message}");
        }
        catch (JsonException ex)
        {
            throw new Exception($"JSON parsing failed: {ex.Message}");
        }
    }
}