If the main address fails, the community runs a backup proxy specifically optimized for Eaglercraft:
pxl.apexmc.co
Verification Status: ⚠️ Verified (Requires 1.5.2 Eaglercraft)
This proxy strips down encryption to make the connection smoother in a browser environment.
Note: Due to the volatile nature of anarchy servers, the direct IP changes frequently to avoid DDoS attacks. As of October 2024, the verified working address is: asspixel server address eaglercraft verified
mc.asspixel.xyzPort: 25565 (Default)
Verification Status: ✅ Verified for Eaglercraft 1.8.8 (Client version "u26" or higher).
How to test it:
What to expect: You will likely be teleported to a "Limbo" lobby where you must type /accept-rules or click a sign to enter the real anarchy world. If the main address fails, the community runs
After scanning community forums (Reddit r/eaglercraft, Discord servers, and GitHub discussions) and testing the connections, here is the current standing.
There are two ways to connect: The Official Bridge vs. Community Proxies.
Pros:
Cons:
Based on standard cybersecurity protocols for web-gaming clients:
If you see a red screen saying "Server is not verified," click "Yes" or "Connect Anyway". This is the "Eaglercraft Verified" step – it means the server accepted your connection but the digital signature is missing, which is fine for anarchy servers.
Save as verifyServer.ts. Requires node 18+, npm packages: net, dns/promises (built-in), axios, crypto.
// verifyServer.ts
import net from "net";
import dns from "dns/promises";
import axios from "axios";
import crypto from "crypto";
import URL from "url";
type Result = null;
fingerprintMatch?: boolean ;
function parseAssPixel(address: string)
async function resolveHost(host: string)
// Try SRV lookup first for minecraft protocol: _minecraft._tcp.host
try
const srv = await dns.resolveSrv(`_minecraft._tcp.$host`);
if (srv && srv.length)
// take first record
return host: srv[0].name, port: srv[0].port ;
catch (e)
// ignore
// fallback to A/AAAA
const addrs = await dns.lookup(host, all: true );
if (!addrs
function tcpPing(host: string, port: number, timeoutMs: number)
return new Promise< latency: number; socket: net.Socket >((resolve, reject) =>
const start = Date.now();
const socket = new net.Socket();
let done = false;
socket.setTimeout(timeoutMs);
socket.once("error", (err) =>
if (done) return;
done = true;
socket.destroy();
reject(err);
);
socket.once("timeout", () =>
if (done) return;
done = true;
socket.destroy();
reject(new Error("timeout"));
);
socket.connect(port, host, () =>
const latency = Date.now() - start;
if (done) return;
done = true;
resolve( latency, socket );
);
);
/*
Basic Minecraft/Eaglercraft ping: send handshake+status request (protocol 47-style is complex).
For simplicity, we use server list ping as a minimal HTTP GET to known endpoints:
- try HTTP(S) http(s)://host:port/status or /.well-known/asspixel-fingerprint
If that fails, we still mark reachable if TCP connection succeeded.
*/
async function fetchHttpInfo(host: string, port: number, path: string, timeoutMs: number)
const httpTry = async (protocol: "http"
function normalizeHex(s: string | null)
if (!s) return null;
return s.replace(/^0x/, "").toLowerCase();
export default async function verifyAssPixelAddress(address: string, opts?: timeoutMs?: number; verifyFingerprint?: boolean; ) : Promise<Result> {
const timeoutMs = opts?.timeoutMs ?? 5000;
const verifyFingerprint = opts?.verifyFingerprint ?? true;
const result: Result = ok: false, reachable: false, fingerprint: null, fingerprintMatch: null, latencyMs: null, motd: null, version: null, error: null ;
let parsed;
try
parsed = parseAssPixel(address);
catch (e: any)
result.error = e.message;
return result;
// Resolve
let resolved;
try
resolved = await resolveHost(parsed.host);
catch (e: any)
result.error = `DNS error: $e.message`;
return result;
const targetPort = parsed.port || resolved.port || 25565;
const targetHost = resolved.host || parsed.host;
// TCP connect
let socket: net.Socket | null = null;
try
const ping = await tcpPing(targetHost, targetPort, timeoutMs);
result.reachable = true;
result.latencyMs = ping.latency;
socket = ping.socket;
socket.destroy();
catch (e: any)
result.reachable = false;
result.error = `TCP connect failed: $e.message`;
return result;
// Try HTTP-based status endpoints for motd/version/fingerprint
try {
const info = await fetchHttpInfo(parsed.host, targetPort, parsed.path, timeoutMs);
if (info) {
// normalize fingerprint if present
let fp: string | null = null;
if (info.data && typeof info.data === "object")
if (info.data.fingerprint) fp = normalizeHex(String(info.data.fingerprint));
if (info.data.motd) result.motd = String(info.data.motd);
if (info.data.version) result.version = String(info.data.version);
else if (typeof info.data === "string") {
// Try to parse JSON
try
const j = JSON.parse(info.data);
if (j.fingerprint) fp = normalizeHex(String(j.fingerprint));
if (j.motd) result.motd = String(j.motd);
if (j.version) result.version = String(j.version);
catch {}
}
result.fingerprint = fp;
}
} catch (e)
// ignore errors; fingerprint may remain unknown
// Fingerprint check
const expected = normalizeHex(parsed.fingerprint);
if (expected)
// If we have fingerprint from server, compare
if (result.fingerprint)
result.fingerprintMatch = (result.fingerprint === expected);
else if (verifyFingerprint)
// try retrieve a TLS cert fingerprint (if HTTPS endpoint worked)
try
// perform HTTPS GET to fetch cert fingerprint
const url = `https://$parsed.host:$targetPort$ "/"`;
const res = await axios.get(url, timeout: timeoutMs, httpsAgent: new (require("https").Agent)( rejectUnauthorized: false ), validateStatus: () => true );
// capture peer certificate from socket if possible
// axios doesn't expose cert; skip unless using tls.connect
catch
// fallback: unknown
result.fingerprintMatch = null;
else
result.fingerprintMatch = null;
result.ok = true;
return result;
}
// Quick CLI usage if run directly
if (require.main === module)
(async () =>
const addr = process.argv[2];
if (!addr) console.error("Usage: node verifyServer.js asspixel://..."); process.exit(2);
const res = await verifyAssPixelAddress(addr, timeoutMs: 5000, verifyFingerprint: true );
console.log(JSON.stringify(res, null, 2));
)();