Documentație API

Ce este Sistemul de Verificare a Voturilor?

Sistemul nostru de verificare a voturilor este o soluție modernă și inovatoare creată special pentru serverele private Metin2. Oferă o modalitate captivantă pentru jucători de a vota pentru serverele lor preferate și de a primi beneficii în joc.

Sistemul este atât ușor de implementat, cât și extrem de fiabil, ceea ce îl face o alegere excelentă pentru proprietarii de servere care doresc să crească implicarea jucătorilor și vizibilitatea serverului.

Scopul nostru este să creăm o situație în care toată lumea câștigă: jucătorii sunt recompensați pentru loialitate prin beneficii în joc, iar serverele se bucură de vizibilitate crescută și implicare mai mare.

Ce este Vote4Buff?

Vote4Buff este soluția noastră premium completă pentru votare, care include o interfață grafică atractivă în joc, comunicare WebSocket și integrare completă cu serverul. Jucătorii pot vota, pot alege din mai multe pachete de bonusuri și primesc instantaneu recompense fără să iasă din joc!

Arhitectura sistemului

Sistemul Vote4Buff este format din trei componente principale:

Partea client

Sistem de UI în Python (uivote4buff.py)
Resurse și elemente grafice UI personalizate
Integrare WebSocket în C++
Suport pentru 11 limbi

Partea server

Integrare API în C++
Gestionarea pachetelor de bonusuri
Sistem de recompense cu obiecte
Monitorizarea efectelor în timp real

Platforma noastră

API de verificare a voturilor
Monitorizare pe baza conturilor
Protecție anti-fraudă
Statusul votului în timp real

Caracteristici cheie

Multiple pachete de bonusuri: până la 3 pachete configurabile din care jucătorii pot alege

Recompense cu obiecte: oferă automat obiecte după un vot reușit

Interfață în timp real: cronometre și urmărirea efectelor direct în joc

Comunicare WebSocket: verificare instantanee fără reîmprospătarea paginii

Multilingv: Suportă 11 limbi (EN, DE, ES, PL, TR, RO, IT, PT, HU, GR, CZ)

Recompense personalizabile: configurează bonusurile, durata și costurile

Perfect pentru: Proprietarii de servere care vor o soluție profesionistă, gata de utilizare, fără să petreacă săptămâni întregi cu dezvoltare personalizată. Trebuie doar să configurezi pachetele de bonusuri, să integrezi fișierele și ești gata!

Cerințe

Vote4Buff este conceput pentru martysama0134 v5.8 ca bază de cod. Dacă folosești o altă sursă, pot fi necesare modificări suplimentare.

Conținutul pachetului

Fișiere client

Fișiere UI Python (uivote4buff.py)
Modificări ale fișierelor clientului de joc
Elemente grafice și resurse UI
Fișiere locale în 11 limbi
Implementare WebSocket în C++
Fișiere script pentru UI

Include libcurl.dll (versiunea 32-bit inclusă, 64-bit disponibilă)

Fișiere server

Configurare char.h
Modificări pentru sistemul de efecte
Integrarea comenzilor de chat
Strat de comunicare cu API-ul
Sistemul de gestionare a bonusurilor

Toate modificările necesare în sursele C++ sunt incluse

Autentificare necesară

Te rugăm să te autentifici pentru a descărca fișierele Vote4Buff.

Toată configurarea Vote4Buff se face în fișierul char.h de pe serverul tău. Mai jos găsești exemple detaliate pentru fiecare opțiune.

Pasul 1: Credenziale API

Mai întâi configurează ID-ul serverului și token-ul API (le găsești în panoul tău):

// 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 !!!

Pasul 2: Configurează pachetele de bonusuri

Poți defini până la 3 pachete de bonusuri din care jucătorii pot alege. Fiecare pachet poate conține mai multe bonusuri:

// 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
    },
};

Tipuri APPLY disponibile

Tipuri de bonus frecvente: 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 multe altele!

Pasul 3: Recompense cu obiecte (opțional)

Configurează obiectele pe care jucătorii le primesc automat după vot:

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
};

Pasul 4: Setări pentru schimbarea bonusurilor

Controlează perioada de așteptare și costurile atunci când jucătorii vor să schimbe pachetele de bonusuri:

// 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)

Notă: După ce jucătorii votează, pot alege gratuit un pachet de bonus. Perioada de așteptare și costul se aplică doar dacă vor să schimbe pachetul fără să voteze din nou.

Înainte să începi

Asigură-te că ai backup pentru fișierele clientului și serverului! Fișierele cu prefix __ necesită modificări, iar cele fără prefix pot fi copiate direct.

Instalarea pe server

1

Configurează char.h

Deschide Source/Server/__char.h din pachetul descărcat.

Găsește class CBuffOnAttributes; și adaugă codul de configurare deasupra (vezi secțiunea de Configurare)
Setează s_VOTE4BUFF_SERVER_ID și s_VOTE4BUFF_API_TOKEN
Configurează pachetele de bonusuri și recompensele cu obiecte
Găsește bool DragonSoul_RefineWindow_CanRefine(); și adaugă declarațiile metodelor publice

2

Aplică modificările pe server

Integrează fișierele din pachet pentru partea de server:

__affect.h - Modifică fișierul tău affect.h cu schimbările furnizate
__chat_affect.cpp - Adaugă gestionarea efectului Vote4Buff
__cmd_general.cpp - Adaugă procesarea comenzilor
__desc_client.cpp - Modificări pentru descriptorul clientului

Notă: Fișierele cu prefix __ indică faptul că trebuie să îmbini modificările cu fișierele existente.

3

Recompilează nucleul jocului

Compilează serverul de joc cu noile modificări.

make clean && make

Instalarea pe client

4

Fișiere UI Python

Din folderul Client/root/:

Copiază uivote4buff.py în folderul root/ al clientului tău
Modifică următoarele fișiere conform instrucțiunilor:
- __constInfo.py
- __game.py
- __interfaceModule.py
- __uiAffectShower.py

5

Grafica și scripturile UI

Copiază folderul Client/ui/game/vote4buff/ în directorul ui/game/ al pack-ului tău
Copiază Client/uiscript/vote4buffwindow.py în folderul uiscript

6

Fișiere de limbă

Adaugă șirurile locale pentru limbile suportate din Client/locale/:

Anexează conținutul __locale_game.txt în locale_game.txt
Anexează conținutul __locale_interface.txt în locale_interface.txt

Limbi disponibile: EN, DE, ES, PL, TR, RO, IT, PT, HU, GR, CZ

7

Modificări C++ pe client

Din Source/Client/UserInterface/:

Copiază M2WebSocket.cpp și M2WebSocket.h în folderul UserInterface
Aplică modificările din fișierele cu prefix __ în fișierele existente
Asigură-te că libcurl.dll este în directorul clientului (versiunea 32-bit inclusă, descarcă varianta 64-bit dacă este necesar)

8

Adaugă un buton în UI (opțional)

Vote4Buff nu adaugă un buton implicit. Trebuie să apelezi ToggleVote4Buff() dintr-un loc al interfeței tale. De exemplu:

Adaugă un buton în SystemDialog
Leagă-l de o tastă rapidă
Adaugă-l în meniul QuickSlot

Sau folosește clasa Vote4BuffButton inclusă, care creează un buton icon dragabil

9

Recompilează clientul

Reconstruiește executabilul clientului cu noile modificări.

10

Testare

Testează integrarea:

Conectează-te pe serverul tău
Deschide fereastra Vote4Buff
Votează pe platforma noastră: https://metin2-toplist.net/vote/en/YOUR_SERVER_ID-server-name/YOUR_ACCOUNT_ID
Revino în joc și verifică votul
Alege un pachet de bonusuri și verifică dacă efectele sunt aplicate
Verifică dacă recompensele cu obiecte au fost primite

Instalare completă!

Acum jucătorii tăi pot vota și primi recompense automat. Interfața Vote4Buff le arată când pot vota, le permite să aleagă pachete de bonusuri și afișează cronometre pentru efectele active.

Promovare gratuită

Majoritatea jucătorilor noi descoperă servere prin toplisturi, ceea ce îl face un instrument de marketing esențial

Configurare simplă

Documentația detaliată și ghidurile pas cu pas fac configurarea foarte ușoară

Fără cod suplimentar

Proces de integrare REST extrem de simplu

Performanță optimizată

Verificarea votului pe partea clientului asigură o încărcare minimă a serverului

Fiabilitate ridicată

Sistem testat în producție, cu protecție anti-fraudă integrată

Verificare vot

Asigură-te că jucătorii chiar au votat pentru serverul tău înainte de a acorda recompense

Avantaje pentru jucători

Primește recompense în joc pentru votare

Interfață de vot ușor de folosit

Afișarea clară a timpului rămas până la următorul vot

Sistem garantat de livrare a recompenselor

Sistemul are un flux clar și intuitiv, ușor de înțeles de către jucători. Cel mai important, verificarea voturilor se face prin API-ul nostru, asigurând validarea voturilor reale!

1. Jucătorul apasă butonul de vot — De pe site-ul tău sau din interfața din joc

2. Redirecționare către pagina de vot — Jucătorul este redirecționat către pagina de vot a serverului tău în toplist

3. Jucătorul votează — Jucătorul completează CAPTCHA și trimite votul

4. Verificarea API — Serverul tău interoghează API-ul nostru pentru a verifica votul

5. Răsplătește jucătorul — Serverul tău acordă recompensa în joc

Alege metoda de integrare în funcție de nevoile tale:

RECOMANDAT

Sistemul Vote4Buff

Soluție completă cu interfață personalizată, comunicare WebSocket și sistem automat de recompense.

Interfață completă în joc
Pachete multiple de bonusuri
Recompense automate cu obiecte
Cronometre în timp real
Suport pentru 11 limbi

Începe cu Vote4Buff

Integrare API personalizată

Construiește-ți propria implementare folosind API-ul nostru REST pentru flexibilitate maximă.

Personalizare completă
Interfață creată de tine
Logică de recompense personalizată
Pe bază de IP sau cont

Folosește API-ul de bază

Pași generali de configurare

1

Înregistrează-ți serverul

Creează un cont și adaugă-ți serverul în toplist la https://metin2-toplist.net/servers/create

2

Obține credențialele API

Găsește ID-ul unic al serverului și token-ul API în panoul serverului. Acestea sunt necesare pentru autentificare.

3

Alege metoda de integrare

Descarcă Vote4Buff pentru o soluție gata de folosit sau integrează API-ul pentru o implementare personalizată.

4

Testează și lansează

Testează sistemul de vot în detaliu, apoi lansează-l pe serverul live.

Notă

Dacă folosești sistemul Vote4Buff (recomandat), acest API este deja integrat! Această secțiune este pentru proprietarii de servere care doresc să construiască implementări personalizate.

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

Parametri necesari

Parametru	Tip	Obligatoriu	Descriere
`api_token`	string	Da	Token-ul API unic al serverului tău
`ip`	string	Opțional*	Adresa IP a jucătorului (IPv4 sau IPv6)
`account_id`	string	Opțional*	ID-ul/username-ul contului jucătorului pentru o urmărire mai precisă

*Fie ip, fie account_id (sau ambele) trebuie furnizate

Pentru rezultate optime, folosește <code>account_id</code> pentru urmărirea exactă a jucătorilor. Metoda <code>ip</code> poate fi mai puțin fiabilă dacă jucătorii folosesc VPN-uri sau se conectează din locații diferite.

Formatul URL-ului de vot

Direcționează jucătorii să voteze folosind această structură de URL:

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

Exemple:
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

Limbi suportate: en, de, es, pl, tr, ro, it, pt, hu, gr, cz

Formatul răspunsului

API-ul returnează un răspuns JSON cu următoarea structură:

{
    "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"
}

Câmpuri ale răspunsului

Câmp	Tip	Descriere
`success`	boolean	Indică dacă cererea API a fost procesată cu succes
`voted`	boolean	Indică dacă a fost găsit un vot valid (apare doar dacă success=true)
`last_vote`	string	Timestamp ISO 8601 al celui mai recent vot (numai dacă voted=true)
`next_vote_in`	integer	Numărul de secunde până la următorul vot permis (numai dacă voted=true)
`message`	string	Mesaj clar care descrie rezultatul

Exemplu 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...";
}
?>

Exemplu Python

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...")

Exemplu C++ (pentru servere de joc)

#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!");
    }
}

Exemplu 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...');
    }
});

Bune practici de securitate

Păstrează token-ul API în siguranță și nu îl expune în codul de pe partea de client. Request-urile către API trebuie făcute întotdeauna din backend-ul serverului.

Pasul 1: Creează butonul/comanda de vot

Adaugă un buton de vot pe site-ul tău sau o comandă în joc care îi direcționează pe jucători către pagina ta de vot la https://metin2-toplist.net/servers/YOUR-SERVER-SLUG.

Pasul 2: Implementează verificarea votului

Când jucătorul solicită recompensa (prin site sau în joc), verifică dacă a votat:

Obține adresa IP a jucătorului
Trimite o cerere către endpoint-ul nostru check-vote
Procesează răspunsul JSON
Dacă voted este true, acordă recompensa
Stochează faptul că ai oferit această recompensă pentru a evita revendicările duble

Pasul 3: Gestionează recompensele

Cele mai bune practici pentru gestionarea recompenselor:

Monitorizează recompensele acordate: Stochează în baza de date ce voturi au fost deja răsplătite pentru a preveni dublarea
Interval între voturi: Respectă perioada de 24 de ore dintre voturi
Gestionarea erorilor: Procesează erorile API cu grijă și informează jucătorii
Jurnalizare: Înregistrează toate verificările de vot pentru analiză și depanare

Flux de lucru exemplu

Jucătorul: tastează comanda /vote în joc

↓

Serverul: deschide browserul către pagina de vot

↓

Jucătorul: votează pe toplist

↓

Jucătorul: tastează comanda /claim sau apasă „Claim Reward”

↓

Serverul: interoghează API-ul cu IP-ul jucătorului

↓

API-ul: returnează voted=true

↓

Serverul: acordă recompensa jucătorului

Eroare „Invalid API token”

Soluție: Verifică dacă folosești token-ul API corect din panoul serverului. Asigură-te că nu există spații sau caractere suplimentare.

Votul nu este detectat după ce jucătorul a votat

Cauze posibile:

Jucătorul folosește un VPN/Proxy (adresele IP nu se potrivesc)
Votul nu a fost încă procesat (așteaptă 30 de secunde și încearcă din nou)
Se trimite o adresă IP greșită către API
Jucătorul a votat pentru un alt server

Timeout sau erori de conexiune ale API-ului

Soluție: Asigură-te că serverul tău poate face request-uri HTTPS. Verifică setările firewall. Implementează retry cu backoff exponențial.

Jucătorii revendică recompense de mai multe ori

Soluție: Implementează urmărirea locală a voturilor recompensate. Stochează timestamp-ul votului și acordă recompensa o singură dată.

Adresele IPv6 nu funcționează

Soluție: Asigură-te că trimiți adresa IPv6 completă. API-ul nostru suportă atât IPv4, cât ș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")

Asistență prin e-mail

Primește ajutor prin e-mail

Contactează suportul

Comunitatea Discord

Alătură-te comunității noastre

Intră pe Discord

Sfat util

Testează integrarea temeinic cu un cont de test înainte de producție. Asigură-te că gestionezi toate scenariile limită și erorile.

Navigare rapidă

Sistemul de verificare a voturilor Metin2

Sistemul Vote4Buff (Recomandat)