IDN 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/idn';

async function getIDNLiveMembers() {
  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 on IDN platform:', data);
    
    // Display member information
    data.forEach(member => {
      console.log(`${member.name} is live on IDN (started: ${new Date(member.started_at).toLocaleTimeString()})`);
    });
    
    return data;
  } catch (error) {
    console.error('Error fetching IDN live members:', error);
  }
}

// Usage
getIDNLiveMembers();

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/idn'

def get_idn_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 on IDN platform")
        
        # Display member information
        for member in data:
            started_time = datetime.fromisoformat(member['started_at'].replace('Z', '+00:00'))
            print(f"- {member['name']} (started: {started_time.strftime('%H:%M:%S')})")
            print(f"  Room ID: {member['room_id']}")
            print(f"  URL Key: {member['url_key']}")
            print()
        
        return data
        
    except requests.exceptions.RequestException as e:
        print(f"Error fetching IDN live members: {e}")
        return None

if __name__ == "__main__":
    get_idn_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/idn';
$url = "{$baseUrl}{$endpoint}?apikey={$apiKey}";

function getIDNLiveMembers($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 IDN 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;
    }
    
    // Display results
    echo "Live members on IDN platform:\n";
    echo "Found " . count($data) . " members\n\n";
    
    foreach ($data as $member) {
        $startedTime = date('H:i:s', strtotime($member['started_at']));
        echo "- {$member['name']} (started: {$startedTime})\n";
        echo "  Room ID: {$member['room_id']}\n";
        echo "  URL Key: {$member['url_key']}\n\n";
    }
    
    return $data;
}

getIDNLiveMembers($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/idn"
)

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 getIDNLiveMembers() ([]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 := getIDNLiveMembers()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    
    fmt.Printf("Found %d live members on IDN platform:\n\n", len(members))
    for _, member := range members {
        startedAt, _ := time.Parse(time.RFC3339, member.StartedAt)
        fmt.Printf("- %s (started: %s)\n", member.Name, startedAt.Format("15:04:05"))
        fmt.Printf("  Room ID: %d\n", member.RoomID)
        fmt.Printf("  URL Key: %s\n\n", member.URLKey)
    }
}

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.List;

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

public class JKT48IDNLiveAPI {
    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/idn";
    
    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 = getIDNLiveMembers();
            
            System.out.println("Found " + members.size() + " live members on IDN platform:\n");
            
            for (LiveMember member : members) {
                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 + ")");
                System.out.println("  Room ID: " + member.room_id);
                System.out.println("  URL Key: " + member.url_key + "\n");
            }
            
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
    
    private static List<LiveMember> getIDNLiveMembers() 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.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;

public class JKT48IDNLiveAPI
{
    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/idn";
    
    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 GetIDNLiveMembersAsync();
            
            Console.WriteLine($"Found {members.Count} live members on IDN platform:\n");
            
            foreach (var member in members)
            {
                if (DateTime.TryParse(member.started_at, out DateTime startedTime))
                {
                    Console.WriteLine($"- {member.name} (started: {startedTime:HH:mm:ss})");
                }
                else
                {
                    Console.WriteLine($"- {member.name}");
                }
                
                Console.WriteLine($"  Room ID: {member.room_id}");
                Console.WriteLine($"  URL Key: {member.url_key}\n");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
    
    private static async Task<List<LiveMember>> GetIDNLiveMembersAsync()
    {
        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}");
        }
    }
}