API Dokumentation - PidChecker.net

📋 Inhaltsverzeichnis

Übersicht Browser (URL) JavaScript HTML + JavaScript HTML + AJAX C++ C# VB.NET PHP JavaScript + PHP Vue.js Python cURL (Terminal) Perl Java Ruby R Rust Swift Lua Dart Batch/PowerShell

🚀 API Übersicht

Basis-URL:
https://pidchecker.net/

Endpunkt: Product Key Validierung
Methode: GET
URL: /?key=PRODUCT_KEY&apikey=YOUR_API_KEY

Parameter:

key - Der zu prüfende Microsoft Produktschlüssel (z.B. XXXXX-XXXXX-XXXXX-XXXXX-XXXXX)
apikey - Ihr persönlicher API-Schlüssel (erhältlich im API-Portal)

Erfolgreiche Antwort:

{
  "success": true,
  "key": "XXXXX-XXXXX-XXXXX-XXXXX-XXXXX",
  "product": "Windows 10 Pro",
  "valid": true,
  "status": "VALID",
  "info": "Additional information..."
}

Fehler-Antwort:

{
  "success": false,
  "error": "invalid_apikey",
  "message": "API key is invalid or expired"
}

Browser Einfacher URL-Aufruf

Öffnen Sie einfach folgende URL in Ihrem Browser:

https://pidchecker.net/?key=XXXXX-XXXXX-XXXXX-XXXXX-XXXXX&apikey=YOUR_API_KEY

💡 Ersetzen Sie YOUR_API_KEY mit Ihrem echten API-Schlüssel.

JavaScript Fetch API

const apiKey = 'YOUR_API_KEY';
const productKey = 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX';

fetch(`https://pidchecker.net/?key=${encodeURIComponent(productKey)}&apikey=${encodeURIComponent(apiKey)}`)
  .then(response => response.json())
  .then(data => {
    if (data.success) {
      console.log('Produkt:', data.product);
      console.log('Status:', data.status);
      console.log('Gültig:', data.valid);
    } else {
      console.error('Fehler:', data.error);
    }
  })
  .catch(error => console.error('Request fehlgeschlagen:', error));

HTML HTML + JavaScript

<!DOCTYPE html>
<html>
<head>
  <title>PID Checker</title>
</head>
<body>
  <input type="text" id="productKey" placeholder="XXXXX-XXXXX-XXXXX-XXXXX-XXXXX">
  <button onclick="checkKey()">Prüfen</button>
  <div id="result"></div>

  <script>
    const API_KEY = 'YOUR_API_KEY';

    async function checkKey() {
      const key = document.getElementById('productKey').value;
      const url = `https://pidchecker.net/?key=${encodeURIComponent(key)}&apikey=${encodeURIComponent(API_KEY)}`;
      
      try {
        const response = await fetch(url);
        const data = await response.json();
        
        if (data.success) {
          document.getElementById('result').innerHTML = `
            <strong>Produkt:</strong> ${data.product}<br>
            <strong>Status:</strong> ${data.status}<br>
            <strong>Gültig:</strong> ${data.valid ? 'Ja' : 'Nein'}
          `;
        } else {
          document.getElementById('result').innerHTML = `<strong>Fehler:</strong> ${data.error}`;
        }
      } catch (error) {
        document.getElementById('result').innerHTML = `<strong>Fehler:</strong> ${error.message}`;
      }
    }
  </script>
</body>
</html>

AJAX jQuery AJAX

<script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
<script>
const API_KEY = 'YOUR_API_KEY';
const productKey = 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX';

$.ajax({
  url: 'https://pidchecker.net/',
  method: 'GET',
  data: {
    key: productKey,
    apikey: API_KEY
  },
  dataType: 'json',
  success: function(data) {
    if (data.success) {
      console.log('Produkt:', data.product);
      console.log('Status:', data.status);
      $('#result').html('<strong>Gültig:</strong> ' + (data.valid ? 'Ja' : 'Nein'));
    } else {
      console.error('Fehler:', data.error);
    }
  },
  error: function(xhr, status, error) {
    console.error('Request fehlgeschlagen:', error);
  }
});
</script>

C++ C++ mit libcurl

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

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

int main() {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    std::string apiKey = "YOUR_API_KEY";
    std::string productKey = "XXXXX-XXXXX-XXXXX-XXXXX-XXXXX";
    std::string url = "https://pidchecker.net/?key=" + productKey + "&apikey=" + apiKey;

    curl = curl_easy_init();
    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
        
        res = curl_easy_perform(curl);
        
        if(res == CURLE_OK) {
            std::cout << "Response: " << readBuffer << std::endl;
        } else {
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
        }
        
        curl_easy_cleanup(curl);
    }
    
    return 0;
}

// Kompilieren mit: g++ -o pidchecker pidchecker.cpp -lcurl

C# C# mit HttpClient

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

class PidChecker
{
    private static readonly HttpClient client = new HttpClient();
    private const string API_KEY = "YOUR_API_KEY";
    
    static async Task Main(string[] args)
    {
        string productKey = "XXXXX-XXXXX-XXXXX-XXXXX-XXXXX";
        string url = $"https://pidchecker.net/?key={Uri.EscapeDataString(productKey)}&apikey={Uri.EscapeDataString(API_KEY)}";
        
        try
        {
            HttpResponseMessage response = await client.GetAsync(url);
            response.EnsureSuccessStatusCode();
            
            string responseBody = await response.Content.ReadAsStringAsync();
            JObject json = JObject.Parse(responseBody);
            
            if ((bool)json["success"])
            {
                Console.WriteLine($"Produkt: {json["product"]}");
                Console.WriteLine($"Status: {json["status"]}");
                Console.WriteLine($"Gültig: {json["valid"]}");
            }
            else
            {
                Console.WriteLine($"Fehler: {json["error"]}");
            }
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"Request fehlgeschlagen: {e.Message}");
        }
    }
}

// Benötigt NuGet: Install-Package Newtonsoft.Json

VB.NET VB.NET mit HttpClient

Imports System.Net.Http
Imports Newtonsoft.Json.Linq

Module PidChecker
    Private ReadOnly client As New HttpClient()
    Private Const API_KEY As String = "YOUR_API_KEY"
    
    Sub Main()
        Dim productKey As String = "XXXXX-XXXXX-XXXXX-XXXXX-XXXXX"
        Dim url As String = $"https://pidchecker.net/?key={Uri.EscapeDataString(productKey)}&apikey={Uri.EscapeDataString(API_KEY)}"
        
        Try
            Dim response As HttpResponseMessage = client.GetAsync(url).Result
            response.EnsureSuccessStatusCode()
            
            Dim responseBody As String = response.Content.ReadAsStringAsync().Result
            Dim json As JObject = JObject.Parse(responseBody)
            
            If CBool(json("success")) Then
                Console.WriteLine($"Produkt: {json("product")}")
                Console.WriteLine($"Status: {json("status")}")
                Console.WriteLine($"Gültig: {json("valid")}")
            Else
                Console.WriteLine($"Fehler: {json("error")}")
            End If
        Catch ex As HttpRequestException
            Console.WriteLine($"Request fehlgeschlagen: {ex.Message}")
        End Try
        
        Console.ReadLine()
    End Sub
End Module

' Benötigt NuGet: Install-Package Newtonsoft.Json

PHP PHP mit file_get_contents

<?php
$apiKey = 'YOUR_API_KEY';
$productKey = 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX';

$url = 'https://pidchecker.net/?' . http_build_query([
    'key' => $productKey,
    'apikey' => $apiKey
]);

$response = file_get_contents($url);
$data = json_decode($response, true);

if ($data['success']) {
    echo "Produkt: " . $data['product'] . "\n";
    echo "Status: " . $data['status'] . "\n";
    echo "Gültig: " . ($data['valid'] ? 'Ja' : 'Nein') . "\n";
} else {
    echo "Fehler: " . $data['error'] . "\n";
}
?>

Alternative mit cURL:

<?php
$apiKey = 'YOUR_API_KEY';
$productKey = 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX';

$url = 'https://pidchecker.net/?' . http_build_query([
    'key' => $productKey,
    'apikey' => $apiKey
]);

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);

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

if ($httpCode == 200) {
    $data = json_decode($response, true);
    if ($data['success']) {
        echo "Produkt: " . $data['product'] . "\n";
        echo "Status: " . $data['status'] . "\n";
        echo "Gültig: " . ($data['valid'] ? 'Ja' : 'Nein') . "\n";
    } else {
        echo "Fehler: " . $data['error'] . "\n";
    }
} else {
    echo "HTTP Error: " . $httpCode . "\n";
}
?>

JS+PHP JavaScript Frontend + PHP Backend

Frontend (HTML + JavaScript):

<input type="text" id="productKey" placeholder="XXXXX-XXXXX-XXXXX-XXXXX-XXXXX">
<button onclick="checkKey()">Prüfen</button>
<div id="result"></div>

<script>
async function checkKey() {
  const key = document.getElementById('productKey').value;
  
  const response = await fetch('check_key.php', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ key: key })
  });
  
  const data = await response.json();
  
  if (data.success) {
    document.getElementById('result').innerHTML = `
      <strong>Produkt:</strong> ${data.product}<br>
      <strong>Status:</strong> ${data.status}
    `;
  } else {
    document.getElementById('result').innerHTML = `<strong>Fehler:</strong> ${data.error}`;
  }
}
</script>

Backend (check_key.php):

<?php
header('Content-Type: application/json');

$API_KEY = 'YOUR_API_KEY';

$input = json_decode(file_get_contents('php://input'), true);
$productKey = $input['key'] ?? '';

$url = 'https://pidchecker.net/?' . http_build_query([
    'key' => $productKey,
    'apikey' => $API_KEY
]);

$response = file_get_contents($url);
echo $response;
?>

Vue.js Vue.js 3 Composition API

<template>
  <div>
    <input v-model="productKey" placeholder="XXXXX-XXXXX-XXXXX-XXXXX-XXXXX" />
    <button @click="checkKey">Prüfen</button>
    
    <div v-if="result">
      <p v-if="result.success">
        <strong>Produkt:</strong> {{ result.product }}<br>
        <strong>Status:</strong> {{ result.status }}<br>
        <strong>Gültig:</strong> {{ result.valid ? 'Ja' : 'Nein' }}
      </p>
      <p v-else>
        <strong>Fehler:</strong> {{ result.error }}
      </p>
    </div>
  </div>
</template>

<script setup>
import { ref } from 'vue';

const API_KEY = 'YOUR_API_KEY';
const productKey = ref('');
const result = ref(null);

const checkKey = async () => {
  const url = `https://pidchecker.net/?key=${encodeURIComponent(productKey.value)}&apikey=${encodeURIComponent(API_KEY)}`;
  
  try {
    const response = await fetch(url);
    result.value = await response.json();
  } catch (error) {
    result.value = { success: false, error: error.message };
  }
};
</script>

Python Python mit requests

import requests

API_KEY = 'YOUR_API_KEY'
product_key = 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX'

url = 'https://pidchecker.net/'
params = {
    'key': product_key,
    'apikey': API_KEY
}

try:
    response = requests.get(url, params=params)
    response.raise_for_status()
    
    data = response.json()
    
    if data['success']:
        print(f"Produkt: {data['product']}")
        print(f"Status: {data['status']}")
        print(f"Gültig: {'Ja' if data['valid'] else 'Nein'}")
    else:
        print(f"Fehler: {data['error']}")
        
except requests.exceptions.RequestException as e:
    print(f"Request fehlgeschlagen: {e}")

# Installation: pip install requests

cURL cURL (Terminal/Bash)

curl "https://pidchecker.net/?key=XXXXX-XXXXX-XXXXX-XXXXX-XXXXX&apikey=YOUR_API_KEY"

Mit JSON Pretty-Print:

curl "https://pidchecker.net/?key=XXXXX-XXXXX-XXXXX-XXXXX-XXXXX&apikey=YOUR_API_KEY" | jq

Mit Variablen:

API_KEY="YOUR_API_KEY"
PRODUCT_KEY="XXXXX-XXXXX-XXXXX-XXXXX-XXXXX"

curl "https://pidchecker.net/?key=${PRODUCT_KEY}&apikey=${API_KEY}" \
  -H "Accept: application/json" \
  -s | jq

Perl Perl mit LWP

#!/usr/bin/perl
use strict;
use warnings;
use LWP::UserAgent;
use JSON;
use URI::Escape;

my $API_KEY = 'YOUR_API_KEY';
my $product_key = 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX';

my $url = 'https://pidchecker.net/?key=' . uri_escape($product_key) . '&apikey=' . uri_escape($API_KEY);

my $ua = LWP::UserAgent->new;
my $response = $ua->get($url);

if ($response->is_success) {
    my $data = decode_json($response->decoded_content);
    
    if ($data->{success}) {
        print "Produkt: ", $data->{product}, "\n";
        print "Status: ", $data->{status}, "\n";
        print "Gültig: ", ($data->{valid} ? "Ja" : "Nein"), "\n";
    } else {
        print "Fehler: ", $data->{error}, "\n";
    }
} else {
    die $response->status_line;
}

# Installation: cpan LWP::UserAgent JSON

Java Java mit HttpURLConnection

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import org.json.JSONObject;

public class PidChecker {
    private static final String API_KEY = "YOUR_API_KEY";
    
    public static void main(String[] args) {
        try {
            String productKey = "XXXXX-XXXXX-XXXXX-XXXXX-XXXXX";
            String urlString = "https://pidchecker.net/?key=" + 
                             URLEncoder.encode(productKey, "UTF-8") + 
                             "&apikey=" + URLEncoder.encode(API_KEY, "UTF-8");
            
            URL url = new URL(urlString);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            conn.setRequestProperty("Accept", "application/json");
            
            if (conn.getResponseCode() == 200) {
                BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
                StringBuilder response = new StringBuilder();
                String line;
                
                while ((line = br.readLine()) != null) {
                    response.append(line);
                }
                br.close();
                
                JSONObject json = new JSONObject(response.toString());
                
                if (json.getBoolean("success")) {
                    System.out.println("Produkt: " + json.getString("product"));
                    System.out.println("Status: " + json.getString("status"));
                    System.out.println("Gültig: " + (json.getBoolean("valid") ? "Ja" : "Nein"));
                } else {
                    System.out.println("Fehler: " + json.getString("error"));
                }
            } else {
                System.out.println("HTTP Error: " + conn.getResponseCode());
            }
            
            conn.disconnect();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Ruby Ruby mit net/http

require 'net/http'
require 'json'
require 'uri'

API_KEY = 'YOUR_API_KEY'
product_key = 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX'

uri = URI.parse("https://pidchecker.net/")
params = { key: product_key, apikey: API_KEY }
uri.query = URI.encode_www_form(params)

begin
  response = Net::HTTP.get_response(uri)
  
  if response.is_a?(Net::HTTPSuccess)
    data = JSON.parse(response.body)
    
    if data['success']
      puts "Produkt: #{data['product']}"
      puts "Status: #{data['status']}"
      puts "Gültig: #{data['valid'] ? 'Ja' : 'Nein'}"
    else
      puts "Fehler: #{data['error']}"
    end
  else
    puts "HTTP Error: #{response.code}"
  end
rescue => e
  puts "Request fehlgeschlagen: #{e.message}"
end

R R mit httr

library(httr)
library(jsonlite)

API_KEY <- "YOUR_API_KEY"
product_key <- "XXXXX-XXXXX-XXXXX-XXXXX-XXXXX"

url <- "https://pidchecker.net/"
response <- GET(url, query = list(key = product_key, apikey = API_KEY))

if (status_code(response) == 200) {
  data <- fromJSON(content(response, "text", encoding = "UTF-8"))
  
  if (data$success) {
    cat("Produkt:", data$product, "\n")
    cat("Status:", data$status, "\n")
    cat("Gültig:", ifelse(data$valid, "Ja", "Nein"), "\n")
  } else {
    cat("Fehler:", data$error, "\n")
  }
} else {
  cat("HTTP Error:", status_code(response), "\n")
}

Rust Rust mit reqwest

use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = "YOUR_API_KEY";
    let product_key = "XXXXX-XXXXX-XXXXX-XXXXX-XXXXX";
    
    let url = format!(
        "https://pidchecker.net/?key={}&apikey={}",
        product_key, api_key
    );
    
    let response = reqwest::get(&url).await?;
    let data: Value = response.json().await?;
    
    if data["success"].as_bool().unwrap_or(false) {
        println!("Produkt: {}", data["product"]);
        println!("Status: {}", data["status"]);
        println!("Gültig: {}", if data["valid"].as_bool().unwrap_or(false) { "Ja" } else { "Nein" });
    } else {
        println!("Fehler: {}", data["error"]);
    }
    
    Ok(())
}

Swift Swift mit URLSession

import Foundation

let API_KEY = "YOUR_API_KEY"
let productKey = "XXXXX-XXXXX-XXXXX-XXXXX-XXXXX"

var components = URLComponents(string: "https://pidchecker.net/")!
components.queryItems = [
    URLQueryItem(name: "key", value: productKey),
    URLQueryItem(name: "apikey", value: API_KEY)
]

guard let url = components.url else {
    print("Invalid URL")
    exit(1)
}

let task = URLSession.shared.dataTask(with: url) { data, response, error in
    if let error = error {
        print("Request fehlgeschlagen: \(error.localizedDescription)")
        return
    }
    
    guard let data = data else {
        print("Keine Daten erhalten")
        return
    }
    
    do {
        if let json = try JSONSerialization.jsonObject(with: data) as? [String: Any] {
            if let success = json["success"] as? Bool, success {
                print("Produkt: \(json["product"] ?? "")")
                print("Status: \(json["status"] ?? "")")
                print("Gültig: \(json["valid"] as? Bool == true ? "Ja" : "Nein")")
            } else {
                print("Fehler: \(json["error"] ?? "")")
            }
        }
    } catch {
        print("JSON Parse Error: \(error)")
    }
}

task.resume()
RunLoop.main.run(until: Date(timeIntervalSinceNow: 5))

Lua Lua mit http.request

local http = require("socket.http")
local json = require("cjson")
local ltn12 = require("ltn12")

local API_KEY = "YOUR_API_KEY"
local product_key = "XXXXX-XXXXX-XXXXX-XXXXX-XXXXX"

local url = string.format(
    "https://pidchecker.net/?key=%s&apikey=%s",
    product_key, API_KEY
)

local response_body = {}
local res, code, headers = http.request{
    url = url,
    sink = ltn12.sink.table(response_body)
}

if code == 200 then
    local data = json.decode(table.concat(response_body))
    
    if data.success then
        print("Produkt: " .. data.product)
        print("Status: " .. data.status)
        print("Gültig: " .. (data.valid and "Ja" or "Nein"))
    else
        print("Fehler: " .. data.error)
    end
else
    print("HTTP Error: " .. code)
end

Dart Dart mit http

import 'dart:convert';
import 'package:http/http.dart' as http;

const String API_KEY = 'YOUR_API_KEY';

Future<void> main() async {
  String productKey = 'XXXXX-XXXXX-XXXXX-XXXXX-XXXXX';
  
  var url = Uri.parse('https://pidchecker.net/').replace(
    queryParameters: {
      'key': productKey,
      'apikey': API_KEY,
    },
  );
  
  try {
    var response = await http.get(url);
    
    if (response.statusCode == 200) {
      var data = jsonDecode(response.body);
      
      if (data['success']) {
        print('Produkt: ${data['product']}');
        print('Status: ${data['status']}');
        print('Gültig: ${data['valid'] ? 'Ja' : 'Nein'}');
      } else {
        print('Fehler: ${data['error']}');
      }
    } else {
      print('HTTP Error: ${response.statusCode}');
    }
  } catch (e) {
    print('Request fehlgeschlagen: $e');
  }
}

Batch Windows Batch/PowerShell

PowerShell:

$API_KEY = "YOUR_API_KEY"
$ProductKey = "XXXXX-XXXXX-XXXXX-XXXXX-XXXXX"

$url = "https://pidchecker.net/?key=$ProductKey&apikey=$API_KEY"

try {
    $response = Invoke-RestMethod -Uri $url -Method Get
    
    if ($response.success) {
        Write-Host "Produkt: $($response.product)"
        Write-Host "Status: $($response.status)"
        Write-Host "Gültig: $(if ($response.valid) { 'Ja' } else { 'Nein' })"
    } else {
        Write-Host "Fehler: $($response.error)"
    }
} catch {
    Write-Host "Request fehlgeschlagen: $_"
}

CMD/Batch mit cURL:

@echo off
set API_KEY=YOUR_API_KEY
set PRODUCT_KEY=XXXXX-XXXXX-XXXXX-XXXXX-XXXXX

curl "https://pidchecker.net/?key=%PRODUCT_KEY%&apikey=%API_KEY%"

pause

⚠️ Rate Limits & Best Practices

🔑 API-Schlüssel geheim halten: Niemals in öffentlichen Repositories oder Client-seitigem Code speichern
⏱️ Rate Limits beachten: Je nach Tarif sind unterschiedliche Limits aktiv
💰 Credits sparen: Jede Anfrage kostet 2 Credits (außer bei Unlimited-Plan)
🔄 Caching empfohlen: Wiederkehrende Abfragen cachen, um Credits zu sparen
🛡️ HTTPS verwenden: Immer verschlüsselte Verbindungen nutzen
📊 Fehlerbehandlung: Immer HTTP-Statuscodes und Fehler-Responses prüfen

💬 Support & Hilfe

Haben Sie Fragen oder benötigen Sie Unterstützung?

📧 E-Mail: support@pidchecker.net
🌐 API-Portal: api_portal.php
📊 API-Status: Dashboard