API Skins Minecraft Moderne

Récupérez instantanément des avatars, corps et vues 3D de joueurs Minecraft avec notre API REST rapide et fiable.

Notch jeb_ Dinnerbone Grumm C418

🎮 Testez l'API en direct

Documentation des Endpoints

GET /avatar/{identifier}

Récupère l'avatar (tête) d'un joueur Minecraft. Retourne une image PNG de la tête du joueur avec ou sans la couche du casque.

Paramètres

identifier Requis Nom d'utilisateur ou UUID du joueur
size Optionnel Taille en pixels (8-512, défaut: 128)
nohelm Optionnel Ajouter ce paramètre pour retirer la couche du casque

🔴 Test en direct

Avatar preview
https://api.skins.minestrator.com/avatar/Notch?size=128 
<!-- Avatar simple -->
<img src="https://api.skins.minestrator.com/avatar/Notch" alt="Notch">

<!-- Avatar grande taille -->
<img src="https://api.skins.minestrator.com/avatar/jeb_?size=256" alt="jeb_">

<!-- Avatar sans casque -->
<img src="https://api.skins.minestrator.com/avatar/Dinnerbone?nohelm" alt="Dinnerbone">
// Fonction pour récupérer un avatar
async function getPlayerAvatar(username, size = 128, noHelm = false) {
  const params = new URLSearchParams();
  params.append('size', size);
  if (noHelm) params.append('nohelm', 'true');
  
  const url = `https://api.skins.minestrator.com/avatar/${username}?${params}`;
  const img = new Image();
  img.src = url;
  return img;
}

// Composant React
function PlayerAvatar({ username, size = 64, noHelm = false }) {
  const params = new URLSearchParams();
  if (size !== 128) params.append('size', size);
  if (noHelm) params.append('nohelm', 'true');
  
  const queryString = params.toString();
  const url = `https://api.skins.minestrator.com/avatar/${username}${queryString ? '?' + queryString : ''}`;
  
  return (
    <img 
      src={url}
      alt={`Avatar de ${username}`}
      className="player-avatar"
      style=={{ imageRendering: 'pixelated' }}
    />
  );
}
<?php
// Classe pour gérer l'API MineSkins
class MineSkins {
    private $baseUrl = 'https://api.skins.minestrator.com';
    
    public function getAvatarUrl($identifier, $size = 128, $noHelm = false) {
        $params = ['size' => $size];
        if ($noHelm) {
            $params['nohelm'] = 'true';
        }
        
        return $this->baseUrl . '/avatar/' . $identifier . '?' . http_build_query($params);
    }
    
    public function displayAvatar($identifier, $size = 128, $noHelm = false) {
        $url = $this->getAvatarUrl($identifier, $size, $noHelm);
        echo "<img src='$url' alt='Avatar de $identifier' style='image-rendering: pixelated;'>";
    }
}

// Utilisation
$api = new MineSkins();
$api->displayAvatar('Notch', 256);
?>
import requests
from PIL import Image
from io import BytesIO

class MineSkins:
    def __init__(self):
        self.base_url = "https://api.skins.minestrator.com"
    
    def get_avatar(self, username, size=128, no_helm=False, save_path=None):
        """Récupère l'avatar d'un joueur Minecraft"""
        url = f"{self.base_url}/avatar/{username}"
        params = {'size': size}
        if no_helm:
            params['nohelm'] = 'true'
        
        response = requests.get(url, params=params)
        
        if response.status_code == 200:
            img = Image.open(BytesIO(response.content))
            
            if save_path:
                img.save(save_path)
            
            return img
        else:
            raise Exception(f"Erreur: {response.status_code}")

# Utilisation
api = MineSkins()
avatar = api.get_avatar('Notch', size=256, save_path='notch_avatar.png')
avatar.show()
GET /body/{identifier}

Récupère le corps complet d'un joueur Minecraft. Retourne une image PNG du personnage entier en vue de face.

Paramètres

identifier Requis Nom d'utilisateur ou UUID du joueur
size Optionnel Largeur en pixels (8-512, défaut: 128)

🔴 Test en direct

Body preview
https://api.skins.minestrator.com/body/jeb_?size=128 
<!-- Corps complet du joueur -->
<img src="https://api.skins.minestrator.com/body/Notch" alt="Corps de Notch">

<!-- Corps avec taille personnalisée -->
<img src="https://api.skins.minestrator.com/body/Dinnerbone?size=256" alt="Corps de Dinnerbone">
// Carte de joueur avec avatar et corps
function PlayerCard({ username }) {
  return (
    <div className="player-card">
      <img 
        src={`https://api.skins.minestrator.com/avatar/${username}?size=64`}
        alt={`Avatar de ${username}`}
        className="avatar"
      />
      <img 
        src={`https://api.skins.minestrator.com/body/${username}?size=128`}
        alt={`Corps de ${username}`}
        className="body"
      />
      <h3>{username}</h3>
    </div>
  );
}
GET /3d/{identifier}

Génère une vue 3D isométrique de la tête du joueur. Parfait pour des interfaces modernes et dynamiques.

Paramètres

identifier Requis Nom d'utilisateur ou UUID du joueur
size Optionnel Taille en pixels (8-512, défaut: 128)
angle Optionnel Angle de rotation en degrés (défaut: 45)

🔴 Test en direct

3D preview
https://api.skins.minestrator.com/3d/Dinnerbone?size=128 
<!-- Vue 3D isométrique -->
<img src="https://api.skins.minestrator.com/3d/Notch" alt="Vue 3D de Notch">

<!-- Vue 3D avec angle personnalisé -->
<img src="https://api.skins.minestrator.com/3d/jeb_?angle=90&size=256" alt="Vue 3D de jeb_">
// Animation de rotation 3D
function Rotating3DAvatar({ username }) {
  const [angle, setAngle] = useState(45);
  
  useEffect(() => {
    const interval = setInterval(() => {
      setAngle(prev => (prev + 5) % 360);
    }, 100);
    
    return () => clearInterval(interval);
  }, []);
  
  return (
    <img 
      src={`https://api.skins.minestrator.com/3d/${username}?angle=${angle}&size=128`}
      alt={`Vue 3D animée de ${username}`}
      style=={{ imageRendering: 'pixelated' }}
    />
  );
}
GET /uuid/{username}

Récupère l'UUID d'un joueur à partir de son nom d'utilisateur. Retourne l'UUID au format standard et formaté.

Paramètres

username Requis Nom d'utilisateur du joueur

🔴 Test en direct

{
  "uuid": "069a79f444e94726a5befca90e38aaf5",
  "uuid_formatted": "069a79f4-44e9-4726-a5be-fca90e38aaf5"
}
https://api.skins.minestrator.com/uuid/Notch
Exemple de réponse
{
  "uuid": "069a79f444e94726a5befca90e38aaf5",
  "uuid_formatted": "069a79f4-44e9-4726-a5be-fca90e38aaf5"
}
// Récupérer l'UUID d'un joueur
async function getPlayerUUID(username) {
  try {
    const response = await fetch(`https://api.skins.minestrator.com/uuid/${username}`);
    
    if (!response.ok) {
      throw new Error(`Joueur non trouvé: ${username}`);
    }
    
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Erreur:', error);
    return null;
  }
}

// Utilisation avec gestion d'erreur
const player = await getPlayerUUID('Notch');
if (player) {
  console.log(`UUID: ${player.uuid}`);
  console.log(`UUID formaté: ${player.uuid_formatted}`);
}
<?php
// Fonction pour obtenir l'UUID d'un joueur
function getPlayerUUID($username) {
    $url = "https://api.skins.minestrator.com/uuid/{$username}";
    
    // Initialiser cURL
    $ch = curl_init($url);
    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 json_decode($response, true);
    } else {
        return null;
    }
}

// Utilisation
$player = getPlayerUUID('Notch');
if ($player) {
    echo "UUID: " . $player['uuid'] . "\n";
    echo "UUID formaté: " . $player['uuid_formatted'] . "\n";
} else {
    echo "Joueur non trouvé\n";
}
?>

Exemples d'intégration

🌐 Site Web - Carte de Joueur

<style>
  .player-card {
    display: flex;
    align-items: center;
    gap: 1.5rem;
    padding: 1.5rem;
    background: #1e293b;
    border-radius: 12px;
    box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3);
    transition: transform 0.3s;
  }
  
  .player-card:hover {
    transform: translateY(-5px);
  }
  
  .player-avatar {
    width: 80px;
    height: 80px;
    image-rendering: pixelated;
    border-radius: 8px;
  }
  
  .player-info h3 {
    color: #4ade80;
    margin-bottom: 0.5rem;
  }
  
  .player-info p {
    color: #94a3b8;
  }
</style>

<div class="player-card">
  <img 
    src="https://api.skins.minestrator.com/3d/Notch?size=80"
    alt="Avatar 3D de Notch"
    class="player-avatar"
  >
  <div class="player-info">
    <h3>Notch</h3>
    <p>Créateur de Minecraft</p>
    <p>Rejoint en 2009</p>
  </div>
</div>

🤖 Bot Discord

const { Client, EmbedBuilder, SlashCommandBuilder } = require('discord.js');

// Commande slash pour afficher le profil d'un joueur
const playerCommand = new SlashCommandBuilder()
  .setName('player')
  .setDescription('Affiche le profil d\'un joueur Minecraft')
  .addStringOption(option =>
    option.setName('pseudo')
      .setDescription('Le pseudo du joueur')
      .setRequired(true)
  );

// Handler de la commande
client.on('interactionCreate', async interaction => {
  if (!interaction.isChatInputCommand()) return;
  
  if (interaction.commandName === 'player') {
    const username = interaction.options.getString('pseudo');
    
    // Créer l'embed
    const embed = new EmbedBuilder()
      .setTitle(`Profil de ${username}`)
      .setColor('#4ade80')
      .setThumbnail(`https://api.skins.minestrator.com/3d/${username}?size=128`)
      .setImage(`https://api.skins.minestrator.com/body/${username}?size=256`)
      .addFields(
        { name: 'Avatar', value: `[Télécharger](https://api.skins.minestrator.com/avatar/${username}?size=512)`, inline: true },
        { name: 'Corps', value: `[Télécharger](https://api.skins.minestrator.com/body/${username}?size=512)`, inline: true }
      )
      .setFooter({ text: 'Powered by MineSkins API - MineStrator.com' })
      .setTimestamp();
    
    await interaction.reply({ embeds: [embed] });
  }
});

⚙️ Plugin Minecraft

import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.map.*;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.net.URL;

public class MineSkinsMaps extends JavaPlugin {
    
    private static final String API_URL = "https://api.skins.minestrator.com";
    
    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        if (command.getName().equalsIgnoreCase("playermap") && sender instanceof Player) {
            if (args.length < 1) {
                sender.sendMessage("§cUtilisation: /playermap <pseudo>");
                return true;
            }
            
            Player player = (Player) sender;
            String targetName = args[0];
            
            // Créer une nouvelle map
            MapView map = Bukkit.createMap(player.getWorld());
            map.getRenderers().clear();
            
            map.addRenderer(new MapRenderer() {
                @Override
                public void render(MapView map, MapCanvas canvas, Player player) {
                    try {
                        // Charger l'avatar depuis l'API
                        URL url = new URL(API_URL + "/body/" + targetName + "?size=128");
                        BufferedImage image = ImageIO.read(url);
                        
                        // Dessiner sur la map
                        canvas.drawImage(0, 0, image);
                        canvas.drawText(10, 10, MinecraftFont.Font, "§2" + targetName);
                        
                    } catch (Exception e) {
                        canvas.drawText(10, 60, MinecraftFont.Font, "§cErreur!");
                    }
                }
            });
            
            // Donner la map au joueur
            player.getInventory().addItem(new ItemStack(Material.FILLED_MAP, 1, map.getId()));
            player.sendMessage("§aMap de " + targetName + " créée!");
            
            return true;
        }
        return false;
    }
}

📱 Application Mobile React Native

import React, { useState } from 'react';
import {
  View,
  Text,
  TextInput,
  TouchableOpacity,
  Image,
  StyleSheet,
  ActivityIndicator
} from 'react-native';

const PlayerProfile = () => {
  const [username, setUsername] = useState('');
  const [loading, setLoading] = useState(false);
  const [playerData, setPlayerData] = useState(null);

  const searchPlayer = async () => {
    if (!username) return;
    
    setLoading(true);
    
    try {
      // Récupérer l'UUID
      const response = await fetch(`https://api.skins.minestrator.com/uuid/${username}`);
      const data = await response.json();
      
      setPlayerData({
        username: username,
        uuid: data.uuid_formatted,
        avatarUrl: `https://api.skins.minestrator.com/avatar/${username}?size=256`,
        bodyUrl: `https://api.skins.minestrator.com/body/${username}?size=256`,
        threeDUrl: `https://api.skins.minestrator.com/3d/${username}?size=256`
      });
    } catch (error) {
      console.error(error);
    } finally {
      setLoading(false);
    }
  };

  return (
    <View style={styles.container}>
      <Text style={styles.title}>Rechercher un joueur</Text>
      
      <View style={styles.searchContainer}>
        <TextInput
          style={styles.input}
          placeholder="Pseudo Minecraft"
          value={username}
          onChangeText={setUsername}
          placeholderTextColor="#666"
        />
        <TouchableOpacity style={styles.button} onPress={searchPlayer}>
          <Text style={styles.buttonText}>Rechercher</Text>
        </TouchableOpacity>
      </View>

      {loading && <ActivityIndicator size="large" color="#4ade80" />}

      {playerData && !loading && (
        <View style={styles.profileCard}>
          <Image source=={{ uri: playerData.threeDUrl }} style={styles.avatar} />
          <Text style={styles.playerName}>{playerData.username}</Text>
          <Text style={styles.uuid}>{playerData.uuid}</Text>
          
          <View style={styles.skinViews}>
            <Image source=={{ uri: playerData.avatarUrl }} style={styles.skinPreview} />
            <Image source=={{ uri: playerData.bodyUrl }} style={styles.skinPreview} />
          </View>
        </View>
      )}
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: '#0f172a',
    padding: 20
  },
  title: {
    fontSize: 24,
    fontWeight: 'bold',
    color: '#4ade80',
    textAlign: 'center',
    marginBottom: 30
  },
  // ... autres styles
});

Fonctionnalités

⚡

Ultra Rapide

Cache intelligent avec support CDN pour des temps de réponse inférieurs à 50ms. Infrastructure distribuée mondialement.

🛡️

Fiabilité 99.9%

Skin par défaut automatique (Steve/Alex) si le joueur n'existe pas. Aucune erreur 404, toujours une réponse valide.

🎨

Flexible

Tailles personnalisables de 8x8 à 512x512 pixels. Support des skins HD et des overlays personnalisés.

🌐

CORS Activé

Utilisable directement depuis n'importe quel site web. Aucune configuration proxy nécessaire.

📦

Cache Optimisé

Headers de cache appropriés pour CDN et navigateurs. Mise à jour automatique toutes les 24h.

🔧

100% Gratuit

Aucune clé API requise, utilisation immédiate. Service gratuit offert par MineStrator.com.

🔒

HTTPS Sécurisé

Toutes les requêtes sont sécurisées via HTTPS. Compatible avec les sites web sécurisés.

📈

Haute Disponibilité

Infrastructure redondante avec failover automatique. Monitoring 24/7 pour garantir la disponibilité.

🎯

Format Standard

Images PNG avec transparence. Compatible avec tous les navigateurs et applications modernes.