Dokumentacja API

Czym jest system weryfikacji głosów?

Nasz system weryfikacji głosów to nowoczesne i innowacyjne rozwiązanie stworzone specjalnie dla prywatnych serwerów Metin2. Zapewnia angażujący sposób, by gracze głosowali na ulubione serwery i otrzymywali korzyści w grze.

System jest zarówno łatwy do wdrożenia, jak i bardzo niezawodny, co czyni go idealnym wyborem dla właścicieli serwerów, którzy chcą zwiększyć zaangażowanie graczy i widoczność serwera.

Naszym celem jest stworzenie sytuacji korzystnej dla wszystkich: gracze otrzymują nagrody za lojalność, a serwery zyskują większą widoczność i aktywność.

Czym jest Vote4Buff?

Vote4Buff to nasze premium, kompletne rozwiązanie do głosowania, obejmujące atrakcyjny interfejs w grze, komunikację WebSocket i pełną integrację z serwerem. Gracze mogą głosować, wybierać spośród wielu zestawów bonusów i natychmiast otrzymywać nagrody bez opuszczania gry!

Architektura systemu

System Vote4Buff składa się z trzech kluczowych komponentów:

Strona klienta

System interfejsu w Pythonie (uivote4buff.py)
Dedykowane zasoby i grafiki UI
Integracja WebSocket w C++
Wsparcie dla 11 języków

Strona serwera

Integracja API w C++
Zarządzanie zestawami bonusów
System nagród przedmiotowych
Śledzenie efektów w czasie rzeczywistym

Nasza platforma

API weryfikacji głosów
Śledzenie na podstawie kont
Zabezpieczenia anty-cheat
Status głosu w czasie rzeczywistym

Kluczowe funkcje

Wiele zestawów bonusów: do 3 konfigurowalnych zestawów, z których gracze mogą wybierać

Nagrody przedmiotowe: automatyczne przedmioty po udanym głosowaniu

Interfejs w czasie rzeczywistym: liczniki i śledzenie efektów w grze

Komunikacja WebSocket: natychmiastowa weryfikacja bez odświeżania strony

Wielojęzyczność: Obsługa 11 języków (EN, DE, ES, PL, TR, RO, IT, PT, HU, GR, CZ)

Konfigurowalne nagrody: ustaw bonusy, czas trwania i koszty

Idealne dla: właścicieli serwerów, którzy chcą profesjonalnego, gotowego rozwiązania bez tygodni własnego developmentu. Wystarczy skonfigurować zestawy bonusów, wdrożyć pliki i gotowe!

Wymagania

Vote4Buff został przygotowany dla bazy źródłowej martysama0134 v5.8. Jeśli korzystasz z innego źródła, mogą być potrzebne dodatkowe modyfikacje.

Zawartość paczki

Pliki klienta

Pliki UI w Pythonie (uivote4buff.py)
Modyfikacje plików klienta gry
Grafiki i zasoby UI
Pliki lokalizacji w 11 językach
Implementacja WebSocket w C++
Skrypty interfejsu

Zawiera libcurl.dll (wersja 32-bit w zestawie, 64-bit dostępna)

Pliki serwera

Konfiguracja char.h
Modyfikacje systemu efektów
Integracja komend czatu
Warstwa komunikacji API
System zarządzania bonusami

W zestawie znajdują się wszystkie niezbędne modyfikacje źródeł C++

Wymagane logowanie

Prosimy zaloguj się, aby pobrać pliki Vote4Buff.

Cała konfiguracja Vote4Buff odbywa się w pliku char.h na Twoim serwerze. Poniżej znajdziesz szczegółowe przykłady dla każdej opcji.

Krok 1: Dane API

Najpierw ustaw ID serwera i token API (znajdziesz je w panelu serwera):

// API SETTINGS from Metin2 Server List
static const std::string s_VOTE4BUFF_SERVER_ID = "YOUR_SERVER_ID"; // From dashboard
static const std::string s_VOTE4BUFF_API_TOKEN = "YOUR_API_TOKEN"; // From dashboard

static const int s_VOTE4BUFF_DURATION = 86400; // seconds (1 day) DO NOT MODIFY THIS !!!

Krok 2: Konfiguracja zestawów bonusów

Możesz zdefiniować maksymalnie 3 zestawy bonusów, z których gracze mogą wybierać. Każdy zestaw może zawierać wiele bonusów:

// Bonuses must be set with its APPLY_ declaration.
// You can add as many bonuses as you want per slot.
static std::vector<std::vector<std::pair<int, int>>> s_VOTE4BUFF_BONUSES =
{
    { // Bonus Pool 1: PvP Focused
        { APPLY_ATTBONUS_HUMAN, 5 },      // +5% vs Players
        { APPLY_DEF_GRADE_BONUS, 50 },    // +50 Defense
    },
    { // Bonus Pool 2: PvE Focused
        { APPLY_ATTBONUS_MONSTER, 5 },    // +5% vs Monsters
        { APPLY_ATTBONUS_INSECT, 5 },     // +5% vs Insects
        { APPLY_HP_REGEN, 10 },           // +10 HP Regen
    },
    { // Bonus Pool 3: Farm Focused
        { APPLY_ITEM_DROP_BONUS, 10 },    // +10% Drop Rate
        { APPLY_EXP_DOUBLE_BONUS, 10 },   // +10% EXP
        { APPLY_GOLD_FIND, 15 },          // +15% Gold
    },
};

Dostępne typy APPLY

Popularne typy bonusów: APPLY_ATTBONUS_HUMAN, APPLY_ATTBONUS_MONSTER, APPLY_DEF_GRADE_BONUS, APPLY_ITEM_DROP_BONUS, APPLY_EXP_DOUBLE_BONUS, APPLY_GOLD_FIND, APPLY_MAX_HP, APPLY_MAX_SP, APPLY_HP_REGEN, APPLY_SP_REGEN, APPLY_CRITICAL_PCT, APPLY_PENETRATE_PCT i wiele innych!

Krok 3: Nagrody przedmiotowe (opcjonalne)

Skonfiguruj przedmioty, które gracze otrzymują automatycznie po weryfikacji głosu:

static std::vector<std::pair<DWORD, int>> s_VOTE4BUFF_ITEM_REWARDS =
{
    // Leave empty if you don't want to give any items as rewards
    // Format: { vnum, count }
    { 27007, 5 },    // 5x Red Potion (XXL)
    { 50084, 1 },    // 1x Gold Bar
    { 71027, 10 },   // 10x Dragon Coin
};

Krok 4: Ustawienia zmiany bonusów

Kontroluj czas odnowienia i koszt, gdy gracze chcą zmienić zestaw bonusów:

// Cooldown when changing bonus (does not apply when choosing right after voting)
static const int s_VOTE4BUFF_CHANGE_BONUS_COOLDOWN = 300; // seconds (5 minutes)

// Price when changing bonus (does not apply when choosing right after voting)
static const int s_VOTE4BUFF_CHANGE_BONUS_PRICE = 15000; // yang (0 = free)

Uwaga: Po oddaniu głosu gracze mogą wybrać zestaw bonusów za darmo. Czas odnowienia i opłata obowiązują tylko przy zmianie zestawu bez ponownego głosowania.

Zanim zaczniesz

Wykonaj kopie zapasowe plików klienta i serwera! Pliki z prefixem __ wymagają scalenia, pozostałe można kopiować bez zmian.

Instalacja na serwerze

1

Konfiguracja char.h

Otwórz plik Source/Server/__char.h z pobranej paczki.

Znajdź class CBuffOnAttributes; i dodaj nad nim kod konfiguracji (zobacz sekcję Konfiguracja)
Ustaw wartości s_VOTE4BUFF_SERVER_ID oraz s_VOTE4BUFF_API_TOKEN
Skonfiguruj zestawy bonusów i nagrody przedmiotowe
Znajdź bool DragonSoul_RefineWindow_CanRefine(); i dodaj deklaracje metod publicznych

2

Zastosuj modyfikacje serwera

Zintegruj pliki serwerowe z paczki:

__affect.h - Scal zmiany z własnym plikiem affect.h
__chat_affect.cpp - Dodaj obsługę efektu Vote4Buff
__cmd_general.cpp - Rozszerz obsługę komend
__desc_client.cpp - Zmodyfikuj deskryptor klienta

Uwaga: Pliki z prefixem __ wymagają ręcznego połączenia ze swoimi plikami.

3

Przekompiluj core gry

Skompiluj serwer gry z wprowadzonymi zmianami.

make clean && make

Instalacja po stronie klienta

4

Pliki UI w Pythonie

Z katalogu Client/root/:

Skopiuj uivote4buff.py do katalogu root/ klienta
Zmodyfikuj poniższe pliki zgodnie z instrukcją:
- __constInfo.py
- __game.py
- __interfaceModule.py
- __uiAffectShower.py

5

Grafika i skrypty UI

Skopiuj katalog Client/ui/game/vote4buff/ do swojego katalogu ui/game/
Skopiuj Client/uiscript/vote4buffwindow.py do folderu uiscript

6

Pliki językowe

Dodaj lokalizacje dla obsługiwanych języków z katalogu Client/locale/:

Dołącz zawartość __locale_game.txt do swojego locale_game.txt
Dołącz zawartość __locale_interface.txt do locale_interface.txt

Obsługiwane języki: EN, DE, ES, PL, TR, RO, IT, PT, HU, GR, CZ

7

Modyfikacje klienta C++

Z katalogu Source/Client/UserInterface/:

Skopiuj M2WebSocket.cpp oraz M2WebSocket.h do katalogu UserInterface
Zastosuj zmiany z plików z prefixem __ w swoich plikach
Upewnij się, że libcurl.dll znajduje się w katalogu klienta (wersja 32-bit w zestawie, 64-bit do pobrania)

8

Dodanie przycisku w UI (opcjonalne)

Vote4Buff nie dodaje domyślnego przycisku. Musisz wywołać ToggleVote4Buff() w swojej UI, na przykład:

Dodaj przycisk do okna SystemDialog
Przypisz go do skrótu klawiszowego
Dodaj do menu QuickSlot

Możesz użyć klasy Vote4BuffButton, która tworzy przesuwalny przycisk z ikoną

9

Przekompiluj klienta

Przebuduj plik wykonywalny klienta z nowymi zmianami.

10

Testowanie

Przetestuj integrację:

Zaloguj się na swój serwer
Otwórz okno Vote4Buff
Zagłosuj na naszej platformie: https://metin2-toplist.net/vote/en/YOUR_SERVER_ID-server-name/YOUR_ACCOUNT_ID
Wróć do gry i zweryfikuj głos
Wybierz zestaw bonusów i sprawdź, czy efekty zostały zastosowane
Upewnij się, że otrzymałeś nagrody przedmiotowe

Instalacja zakończona!

Twoi gracze mogą teraz głosować i automatycznie otrzymywać nagrody. Interfejs Vote4Buff pokazuje, kiedy mogą głosować, pozwala wybrać bonus i wyświetla liczniki dla aktywnych efektów.

Darmowa promocja

Większość nowych graczy znajduje serwery poprzez toplisty, co czyni je kluczowym narzędziem marketingowym

Prosta konfiguracja

Szczegółowa dokumentacja i instrukcje krok po kroku czynią konfigurację banalną

Bez kodowania

Łatwy proces integracji REST API

Wydajność

Weryfikacja głosu po stronie klienta minimalizuje obciążenie serwera

Niezawodność

Sprawdzony system z wbudowanymi zabezpieczeniami przeciw oszustwom

Weryfikacja głosu

Upewnij się, że gracze faktycznie zagłosowali, zanim otrzymają nagrody

Korzyści dla graczy

Nagrody w grze za głosowanie

Łatwy w obsłudze interfejs głosowania

Czytelny licznik czasu do kolejnego głosu

Gwarantowana dostawa nagród

System posiada prosty i intuicyjny przebieg, który gracze łatwo rozumieją. Co najważniejsze, weryfikacja głosu odbywa się przez nasze API, więc masz pewność, że nagradzasz prawdziwe głosy!

1. Gracz klika przycisk głosowania — Na Twojej stronie lub w interfejsie gry

2. Przekierowanie na stronę głosowania — Gracz trafia na stronę głosowania Twojego serwera w topliscie

3. Gracz oddaje głos — Gracz wykonuje CAPTCHA i wysyła głos

4. Weryfikacja API — Twój serwer sprawdza głos przez nasze API

5. Nagrodź gracza — Twój serwer przyznaje nagrodę w grze

Wybierz metodę integracji odpowiednią dla Twoich potrzeb:

POLECANE

System Vote4Buff

Gotowe rozwiązanie z interfejsem w grze, komunikacją WebSocket i automatycznymi nagrodami.

Pełny interfejs w grze
Wiele zestawów bonusów
Automatyczne nagrody przedmiotowe
Liczniki w czasie rzeczywistym
Obsługa 11 języków

Zacznij z Vote4Buff

Własna integracja API

Zbuduj własną implementację przy użyciu naszego REST API, aby mieć pełną kontrolę.

Pełna personalizacja
Twój własny interfejs
Niestandardowa logika nagród
Na podstawie IP lub konta

Użyj podstawowego API

Ogólne kroki konfiguracji

1

Zarejestruj serwer

Utwórz konto i dodaj swój serwer do naszej toplisty pod https://metin2-toplist.net/servers/create

2

Pobierz dane API

Znajdź unikalne ID serwera i token API w panelu serwera. Są wymagane do autoryzacji.

3

Wybierz metodę integracji

Pobierz Vote4Buff dla gotowego rozwiązania lub skorzystaj z API, aby zbudować własne.

4

Przetestuj i wdroż

Dokładnie przetestuj system głosowania, następnie wdroż go na serwerze produkcyjnym.

Uwaga

Jeśli korzystasz z systemu Vote4Buff (zalecane), ten endpoint jest już zintegrowany! Ta sekcja przeznaczona jest dla właścicieli serwerów, którzy chcą zbudować własne rozwiązanie.

GET https://metin2-toplist.net/api/check-vote

Wymagane parametry

Parametr	Typ	Wymagany	Opis
`api_token`	string	Tak	Unikalny token API Twojego serwera
`ip`	string	Opcjonalnie*	Adres IP gracza (IPv4 lub IPv6)
`account_id`	string	Opcjonalnie*	ID/nazwa konta gracza dla dokładniejszego śledzenia

*Należy podać ip lub account_id (albo oba)

Najlepsze rezultaty uzyskasz korzystając z parametru <code>account_id</code>, aby dokładnie identyfikować graczy. Metoda <code>ip</code> może być mniej wiarygodna, jeśli używają VPN lub grają z różnych miejsc.

Format URL głosowania

Kieruj graczy na głosowanie za pomocą następującego adresu:

https://metin2-toplist.net/vote.{lang}/{server_id}-{server_slug}/{account_id}

Przykłady:
https://metin2-toplist.net/vote.en/123-awesome-server/PlayerName
https://metin2-toplist.net/vote.de/123-awesome-server/PlayerName
https://metin2-toplist.net/vote.tr/123-awesome-server/PlayerName

Obsługiwane języki: en, de, es, pl, tr, ro, it, pt, hu, gr, cz

Format odpowiedzi

API zwraca odpowiedź JSON o następującej strukturze:

{
    "success": true,
    "voted": true,
    "last_vote": "2025-11-11T14:30:00Z",
    "next_vote_in": 0,
    "message": "Vote verified successfully"
}

{
    "success": true,
    "voted": false,
    "message": "No recent vote found"
}

{
    "success": false,
    "message": "Invalid API token"
}

Pola odpowiedzi

Pole	Typ	Opis
`success`	boolean	Czy żądanie API zakończyło się powodzeniem
`voted`	boolean	Czy znaleziono ważny głos (tylko gdy success=true)
`last_vote`	string	Znacznik czasu ISO 8601 ostatniego głosu (tylko gdy voted=true)
`next_vote_in`	integer	Liczba sekund do następnego dozwolonego głosu (tylko gdy voted=true)
`message`	string	Opisowy komunikat wyjaśniający wynik

Przykład PHP

<?php
function checkVote($apiToken, $playerIP) {
    $url = "https://metin2-toplist.net/api/check-vote";
    $params = http_build_query([
        'api_token' => $apiToken,
        'ip' => $playerIP
    ]);

    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url . '?' . $params);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
    curl_setopt($ch, CURLOPT_TIMEOUT, 10);

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode !== 200) {
        return ['success' => false, 'message' => 'API request failed'];
    }

    return json_decode($response, true);
}

$result = checkVote('YOUR_API_TOKEN', $_SERVER['REMOTE_ADDR']);
if ($result['success'] && $result['voted']) {
    echo "Vote verified! Rewarding player...";
}
?>

Przykład w Pythonie

import requests

def check_vote(api_token, player_ip):
    url = "https://metin2-toplist.net/api/check-vote"
    params = {'api_token': api_token, 'ip': player_ip}
    try:
        response = requests.get(url, params=params, timeout=10)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        return {'success': False, 'message': f'API request failed: {str(e)}'}

result = check_vote('YOUR_API_TOKEN', '123.456.789.012')
if result.get('success') and result.get('voted'):
    print("Vote verified! Rewarding player...")

Przykład C++ (dla serwerów gry)

#include <curl/curl.h>
#include <string>
#include <sstream>

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

bool CheckVote(const std::string& apiToken, const std::string& playerIP) {
    CURL* curl = curl_easy_init();
    if (!curl) return false;

    std::string readBuffer;
    std::ostringstream url;
    url << "https://metin2-toplist.net/api/check-vote"
        << "?api_token=" << apiToken
        << "&ip=" << playerIP;

    curl_easy_setopt(curl, CURLOPT_URL, url.str().c_str());
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);

    CURLcode res = curl_easy_perform(curl);
    curl_easy_cleanup(curl);

    return (res == CURLE_OK) && (readBuffer.find("\"voted\":true") != std::string::npos);
}

void OnPlayerRequestReward(const std::string& playerName, const std::string& playerIP) {
    if (CheckVote("YOUR_API_TOKEN", playerIP)) {
        GiveItemToPlayer(playerName, REWARD_ITEM_VNUM, REWARD_COUNT);
        SendNotice("Vote verified! You received your reward!");
    } else {
        SendNotice("No valid vote found. Please vote first!");
    }
}

Przykład JavaScript/Node.js

async function checkVote(apiToken, playerIP) {
    const url = new URL('https://metin2-toplist.net/api/check-vote');
    url.searchParams.append('api_token', apiToken);
    url.searchParams.append('ip', playerIP);

    try {
        const response = await fetch(url, {
            method: 'GET',
            headers: { 'Accept': 'application/json' }
        });
        if (!response.ok) throw new Error(`HTTP ${response.status}`);
        return await response.json();
    } catch (error) {
        return { success: false, message: error.message };
    }
}

checkVote('YOUR_API_TOKEN', '123.456.789.012').then(result => {
    if (result.success && result.voted) {
        console.log('Vote verified! Rewarding player...');
    }
});

Najlepsze praktyki bezpieczeństwa

Przechowuj token API w bezpiecznym miejscu i nigdy nie udostępniaj go w kodzie po stronie klienta. Wszystkie żądania API wykonuj z backendu serwera.

Krok 1: Dodaj przycisk/komendę głosowania

Dodaj na stronie lub w grze przycisk, który przekieruje graczy na stronę głosowania pod adresem https://metin2-toplist.net/servers/YOUR-SERVER-SLUG.

Krok 2: Implementuj weryfikację głosu

Gdy gracz prosi o nagrodę (na stronie lub w grze), wykonaj poniższe kroki:

Pobierz adres IP gracza
Wyślij zapytanie do endpointu check-vote
Przetwórz odpowiedź JSON
Jeśli voted to true, przyznaj nagrodę
Zapisz informację o przyznaniu nagrody, aby uniknąć duplikatów

Krok 3: Obsługa nagród

Dobre praktyki przy przyznawaniu nagród:

Śledź przyznane nagrody: Zapisuj w bazie, które głosy zostały już nagrodzone
Limit czasu głosowania: Przestrzegaj 24-godzinnego limitu między głosami
Obsługa błędów: Obsługuj błędy API i informuj o nich graczy
Logowanie: Loguj wszystkie weryfikacje głosów do analizy i debugowania

Przykładowy przebieg

Gracz: wpisuje komendę /vote w grze

↓

Serwer: otwiera przeglądarkę na stronie głosowania

↓

Gracz: głosuje w topliscie

↓

Gracz: wpisuje komendę /claim lub klika "Claim Reward"

↓

Serwer: wysyła zapytanie do API z adresem IP gracza

↓

API: zwraca voted=true

↓

Serwer: przyznaje nagrodę graczowi

Błąd "Invalid API token"

Rozwiązanie: Sprawdź, czy używasz poprawnego tokena API z panelu serwera. Upewnij się, że nie ma dodatkowych spacji ani znaków.

Nie wykryto głosu mimo oddania

Możliwe przyczyny:

Gracz używa VPN/Proxy (adresy IP się nie zgadzają)
Głos nie został jeszcze przetworzony (poczekaj 30 sekund i spróbuj ponownie)
Do API wysyłany jest błędny adres IP
Gracz zagłosował na inny serwer

Timeout lub błędy połączenia z API

Rozwiązanie: Upewnij się, że serwer może wykonywać zapytania HTTPS. Sprawdź ustawienia firewalla i zaimplementuj ponawianie z backoffem wykładniczym.

Gracze wielokrotnie odbierają nagrody

Rozwiązanie: Prowadź lokalny rejestr nagrodzonych głosów. Zapisuj znacznik czasu i wydaj nagrodę tylko raz.

Adresy IPv6 nie działają

Rozwiązanie: Upewnij się, że przesyłasz pełny adres IPv6. Nasze API obsługuje zarówno IPv4, jak i IPv6.

Base URL

https://metin2-toplist.net/api/v1

Rate Limits

Endpoint	Method	Limit	Auth
`/api/v1/servers`	GET	60/min	—
`/api/v1/servers/{slug}`	GET	60/min	—
`/api/v1/servers`	POST	3/hour	—
`/api/v1/servers/claim`	POST	10/hour	✅

List Servers

Retrieve a paginated list of active, launched servers. Supports filtering by category and language.

Parameter	Type	Default	Description
`category`	string	—	Filter by category: oldschool, newschool, fun, pvp, pvm, pve
`language`	string	—	Filter by language code: EN, DE, TR, etc.
`sort`	string	`votes`	Sort order: votes, newest, name
`page`	integer	`1`	Page number
`per_page`	integer	`25`	Results per page (max 50)

curl -H "Accept: application/json" \
  "https://metin2-toplist.net/api/v1/servers?category=pvp&language=EN&per_page=10"

Submit a New Server

Submit a new server listing via the API. The server enters a moderation queue and must be approved before it appears publicly.

Moderation Queue

All API-submitted servers start as inactive and require manual approval. This prevents spam and ensures listing quality.

Field	Type	Required	Description
`name`	string	✅	Server name (max 255 chars, must be unique)
`description`	string	✅	Server description (min 20, max 5000 chars)
`website_url`	string	—	Server website URL
`discord_url`	string	—	Discord invite URL
`languages`	array	✅	Language codes, e.g. ["EN", "DE"] (min 1, max 5)
`category`	string	—	One of: oldschool, newschool, fun, pvp, pvm, pve
`launch_date`	string	—	Future launch date (YYYY-MM-DD)
`owner_email`	string	—	Contact email (optional, not shown publicly)

curl -X POST "https://metin2-toplist.net/api/v1/servers" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "name": "Dragon Kingdom",
    "description": "A classic PvP experience with custom dungeons and weekly events.",
    "languages": ["EN", "DE"],
    "category": "pvp",
    "website_url": "https://dragon-kingdom.com",
    "discord_url": "https://discord.gg/example"
  }'

{
  "success": true,
  "message": "Server submitted successfully!",
  "data": {
    "id": 42,
    "slug": "dragon-kingdom",
    "status": "pending_review"
  },
  "claim_token": "a1b2c3d4...80 characters",
  "note": "Save this token! Use it to claim your listing."
}

Claim Token System

When you submit a server, you receive a unique 80-character claim token. This token lets you link the listing to your account later.

The claim token is shown only once in the API response. Save it immediately — we store only the hash.

1

Submit

POST your server to /api/v1/servers and save the claim_token from the response.

2

Register

Create an account and paste the token in the optional "Claim Token" field.

3

Manage

Your server is now linked to your account with full dashboard access.

Error Codes

Code	Meaning
`200`	Success
`201`	Server created (pending review)
`401`	Authentication required (claim endpoint)
`404`	Server not found / invalid claim token
`409`	Server already claimed
`410`	Claim token expired
`422`	Validation error / spam rejected
`429`	Rate limit exceeded

Integration Examples

$response = file_get_contents('https://metin2-toplist.net/api/v1/servers?per_page=10');
$data = json_decode($response, true);

foreach ($data['data'] as $server) {
    echo $server['name'] . ' — ' . $server['vote_count'] . ' votes' . PHP_EOL;
}

const res = await fetch('https://metin2-toplist.net/api/v1/servers?category=pvp');
const { data, meta } = await res.json();

data.forEach(server => {
  console.log(`${server.name}: ${server.vote_count} votes`);
});

import requests

resp = requests.get('https://metin2-toplist.net/api/v1/servers', params={
    'language': 'DE',
    'sort': 'newest',
    'per_page': 20
})
servers = resp.json()['data']

for s in servers:
    print(f"{s['name']} — {s['vote_count']} votes")

Wsparcie e-mail

Uzyskaj pomoc przez e-mail

Skontaktuj się ze wsparciem

Społeczność Discord

Dołącz do naszej społeczności

Dołącz do Discorda

Wskazówka praktyczna

Przetestuj integrację na koncie testowym przed wdrożeniem na produkcję. Upewnij się, że obsługujesz wszystkie przypadki brzegowe i błędy.

Szybka nawigacja

System weryfikacji głosów dla Metin2

System Vote4Buff (zalecany)