API Tester

import requests

BASE_URL = 'https://proudlyauthentication.com/api/v1'

# 1. Initialize handshake
init_response = requests.get(BASE_URL, params={
    'route': '{admin}/{app}/init'
})
print(init_response.json())
session_id = init_response.json().get('session_id')

# 2. Call action
response = requests.post(BASE_URL, data={
    'route': '{admin}/{app}/getsubscriptions',
    'sessionid': session_id
})
print(response.json())

#include <curl/curl.h>
#include <nlohmann/json.hpp>
#include <iostream>

using json = nlohmann::json;

size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* s) {
    s->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL* curl = curl_easy_init();
    std::string readBuffer;
    
    // 1. Init handshake
    std::string url = "https://proudlyauthentication.com/api/v1?route={admin}/{app}/init";
    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
    curl_easy_perform(curl);
    
    auto resp = json::parse(readBuffer);
    std::string session_id = resp["session_id"];
    
    // 2. Call action
    std::string postData = "route={admin}/{app}/getsubscriptions&sessionid=" + session_id;
    curl_easy_setopt(curl, CURLOPT_POST, 1L);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postData.c_str());
    curl_easy_perform(curl);
    
    curl_cleanup(curl);
    return 0;
}

using System;
using System.Net.Http;
using Newtonsoft.Json;
using System.Threading.Tasks;

class Program {
    static async Task Main() {
        var client = new HttpClient();
        string baseUrl = "https://proudlyauthentication.com/api/v1";
        
        // 1. Init handshake
        var initUrl = $"{baseUrl}?route={{admin}}/{{app}}/init";
        var initResp = await client.GetAsync(initUrl);
        var json = JsonConvert.DeserializeObject<dynamic>(
            await initResp.Content.ReadAsStringAsync()
        );
        string sessionId = json.session_id;
        
        // 2. Call action
        var content = new FormUrlEncodedContent(new[] {
            new KeyValuePair<string, string>("route", "{admin}/{app}/getsubscriptions"),
            new KeyValuePair<string, string>("sessionid", sessionId)
        });
        var resp = await client.PostAsync(baseUrl, content);
        Console.WriteLine(await resp.Content.ReadAsStringAsync());
    }
}

const BASE_URL = 'https://proudlyauthentication.com/api/v1';

async function testAPI() {
  // 1. Init handshake
  const initResp = await fetch(
    `${BASE_URL}?route={admin}/{app}/init`
  );
  const initData = await initResp.json();
  const sessionId = initData.session_id;
  console.log('Session ID:', sessionId);
  
  // 2. Call action
  const resp = await fetch(BASE_URL, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded'
    },
    body: new URLSearchParams({
      route: '{admin}/{app}/getsubscriptions',
      sessionid: sessionId
    })
  });
  const data = await resp.json();
  console.log('Response:', data);
}

testAPI();

import java.net.*;
import java.io.*;
import org.json.JSONObject;

public class APITester {
    public static void main(String[] args) throws Exception {
        String baseUrl = "https://proudlyauthentication.com/api/v1";
        
        // 1. Init handshake
        URL initUrl = new URL(baseUrl + "?route={admin}/{app}/init");
        HttpURLConnection conn = (HttpURLConnection) initUrl.openConnection();
        conn.setRequestMethod("GET");
        
        BufferedReader reader = new BufferedReader(
            new InputStreamReader(conn.getInputStream())
        );
        JSONObject initResp = new JSONObject(reader.lines()
            .collect(StringBuilder::new, StringBuilder::append,
            StringBuilder::append).toString());
        String sessionId = initResp.getString("session_id");
        
        // 2. Call action
        URL url = new URL(baseUrl);
        conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setDoOutput(true);
        
        String data = "route={admin}/{app}/getsubscriptions&sessionid=" + sessionId;
        try(OutputStream os = conn.getOutputStream()) {
            os.write(data.getBytes());
        }
        
        reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        System.out.println(reader.lines()
            .collect(StringBuilder::new, StringBuilder::append,
            StringBuilder::append).toString());
    }
}

package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
    "encoding/json"
)

func main() {
    baseURL := "https://proudlyauthentication.com/api/v1"
    
    // 1. Init handshake
    initResp, _ := http.Get(baseURL + "?route={admin}/{app}/init")
    defer initResp.Body.Close()
    
    body, _ := io.ReadAll(initResp.Body)
    var initData map[string]interface{}
    json.Unmarshal(body, &initData)
    sessionId := initData["session_id"].(string)
    
    // 2. Call action
    data := url.Values{}
    data.Set("route", "{admin}/{app}/getsubscriptions")
    data.Set("sessionid", sessionId)
    
    resp, _ := http.PostForm(baseURL, data)
    defer resp.Body.Close()
    
    body, _ = io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

# 1. Init handshake
curl -s "https://proudlyauthentication.com/api/v1?route={admin}/{app}/init"

# Response will include session_id and secret
# Copy the session_id and use in next request

# 2. Get subscriptions (using session)
curl -s -X POST "https://proudlyauthentication.com/api/v1" \
  -d "route={admin}/{app}/getsubscriptions" \
  -d "sessionid=YOUR_SESSION_ID_HERE"

# Other common actions:
# Login:
curl -s -X POST "https://proudlyauthentication.com/api/v1" \
  -d "route={admin}/{app}/login" \
  -d "username=alice" \
  -d "password=secret"

# Get profile picture by username:
curl -s -X POST "https://proudlyauthentication.com/api/v1" \
  -d "route={admin}/{app}/getprofilepicturebyusername" \
  -d "target_username=bob" \
  -d "sessionid=YOUR_SESSION_ID"