Transformice Api -

The "Transformice API" typically refers to the Lua Module API

, a powerful scripting system that allows players to create custom minigames (known as "modules"), automated tribe house activities, and specialized room events 1. The Lua Module API The core of Transformice development is built on the Lua scripting language

. Players can use it to manipulate game physics, track player actions, and design unique user interfaces. Primary Functions : Developers use events like eventChatCommand to trigger scripts via chat, or eventKeyboard to track player movement and key presses. : Any player can test scripts in their Tribe House

followed by their code. Larger, community-wide modules (like ) are managed by the Module Team

, a group of volunteer developers with access to persistent databases and official room hosting. Documentation official Lua help can be accessed in-game by typing

, which provides a live tree of all available functions and events. 2. Bot & External APIs

For developers looking to interact with the game from outside the client, there are unofficial but widely used libraries: Transfromage : An asynchronous Python and Luvit-based API

designed for creating game bots. It requires an API token (often applied for through community managers) to access the game's encryption keys. Connection Key Parsers : Tools like TransformiceKeys

help developers retrieve the necessary connection tokens and keys required to establish a socket connection with the Atelier 801 servers. 3. Data Retrieval & Statistics

While there isn't a traditional REST API for player global stats, the community uses several methods to pull data: Web Scrapers

: Platforms often crawl server images or shop banners to track new items and events. Third-Party Trackers : Sites like PlayTracker

aggregate player counts and achievements, though they often rely on Steam's API rather than a direct Transformice endpoint. sample Lua script to see how a basic Transformice module is structured? Lua | Transformice Wiki | Fandom

Mastering the Cheese: A Deep Dive into the Transformice API If you’ve ever wanted to track your stats, build a custom leaderboard, or create a unique tribe tool, the Transformice API is your ticket to the back-end of the cheese-loving universe. Developed by Atelier 801, this API allows the community to pull real-time data from the game and build the fansites we all rely on.

Here is everything you need to know about getting started with the Transformice API and the tools available to you. What is the Transformice API?

The Transformice API (often called the Web API) is a set of interfaces provided by Atelier 801 that allows developers to access game-specific data. Instead of manual scraping, the API provides a structured way to retrieve:

Player Profiles: Stats like cheese gathered, firsts, and shaman saves.

Leaderboards: Global and local rankings for various game modes. Tribe Data: Member lists and tribe house statistics.

Wardrobes & Skill Trees: Visual data on mouse customization and shaman progress. Lua vs. The Web API

It’s important to distinguish between the two ways you can "code" for Transformice:

Lua Scripting: Used inside the game to create custom room modules, mini-games, and tribe house scripts. You can find the latest functions by typing /luahelp in-game or checking the Transformice Wiki.

Web API: Used outside the game (on websites or apps) to fetch data from the servers for display on external platforms. Popular Community Projects

The API has birthed some incredible community-led projects that have become staples of the game:

Micetigri: One of the most famous fansites that utilizes the API to show 30-day stat evolutions, title progression, and detailed player wardrobes.

Discord Bots: Many tribes use the API to create Discord integrations that announce when a member hits a milestone or to display a "shaman of the week."

Leaderboard Trackers: Sites that archive the Top 1000 players globally, providing historical data that the game client doesn't store. How to Get Started

If you’re a developer looking to build your own tool, start here:

Documentation: Keep an eye on the Atelier 801 Forums, specifically the "API" and "Lua" sections, where developers share library updates and wrapper code.

Community Libraries: Look for Python or Node.js wrappers on GitHub that simplify the process of connecting to the game's socket servers.

Respect the Rate Limits: Like any API, Atelier 801 has limits. Ensure your tool doesn't spam the servers, or your IP might get blocked. Final Thoughts transformice api

The Transformice API is what keeps the community vibrant outside of the game client. Whether you're a casual player checking your progress on Micetigri or a coder building the next big module, the API opens up a world of possibilities beyond just collecting cheese.

Are you planning to build a tool or looking for a specific stat tracker? Let me know, and I can help you find the right resources!

Technical Overview: The Transformice API Ecosystem In the context of the multiplayer platformer Transformice

, the term "API" refers to two primary systems: the Module API (built on Lua) used for in-game content creation, and external Stats/Bot APIs used for community-driven websites and automation. 1. The In-Game Module API (Lua)

The Module API allows players to write scripts that run within tribe houses or official "module" rooms. It is the foundation for almost all community-created minigames like #prophunt or #pictionary.

Execution Environment: Scripts are executed via the /lua command. Access is restricted to players with specific tribe permissions or members of the official Module Team. Core Packages:

tfm.get: Retrieves room data, including player lists and XML map info.

tfm.exec: Executes game actions like spawning objects, moving mice, or changing scores. system: Manages file loading and basic script metadata.

ui: Allows developers to create custom buttons, text areas, and popup windows.

Event-Driven Architecture: Scripts respond to real-time triggers, such as:

eventChatCommand: Triggers when a player types a command starting with "!".

eventLoop: Occurs every 500 milliseconds, serving as the script's "heartbeat".

eventKeyboard: Captures player key presses for custom movement or mechanics. 2. External Statistics and Bot APIs

Beyond in-game scripting, external APIs allow for deep interaction with game data and player profiles.

Official Stats API: Atelier 801 provides access to a table schema that includes player IDs, shaman experience, titles, and specific game mode data (Racing, Survivor, etc.).

Transfromage API: A third-party project using the Luvit runtime to enable bot connections to the game servers. It requires specific encryption keys and a token to function.

Community Platforms: Sites like Formice utilize these data feeds to provide real-time leaderboards and historical player rankings. 3. Developer Tools and Optimization

The community has developed several tools to handle the limitations of the Lua environment, which does not natively support complex file structures. Lua | Transformice Wiki | Fandom

As of April 2026, there is no single "official" academic paper for the Transformice API; however, comprehensive technical documentation and community-driven guides serve as the primary "informative papers" for the platform's two main API branches: the Module API (Lua) and the External Client/Bot APIs. 1. The Module API (Lua)

The most common way to interact with the game's internal systems is through the Module API. This allows users to create minigames and scripts directly within the game client.

Primary Documentation: The Lua Documentation on the Atelier 801 Forum is the definitive resource. It covers:

Events: Triggers like eventNewPlayer, eventChatCommand, and eventLoop .

Functions: System commands to move players, spawn objects (shaman items), or change map properties .

UI Controls: Documentation for creating custom buttons, text areas, and popup windows .

Technical Basics: It uses the Lua scripting language, which is lightweight and fast, making it ideal for the game's Adobe AIR/Flash-based engine . 2. External APIs (Bots and Data)

For developers looking to create external tools, Discord bots, or leaderboard trackers, several community-driven APIs exist.

Transfromage: An asynchronous Lua runtime (using Luvit) that allows developers to create standalone bots that connect to the game servers .

Transformice-Records: A GitHub repository containing scripts used to track player statistics and map data . The "Transformice API" typically refers to the Lua

Unofficial Wiki: The Transformice Wiki's Lua section acts as a living "informative paper," cataloging version updates (like 0.19) and community-discovered tricks . 3. Key Concepts for Developers

If you are writing a technical overview, these are the essential pillars:

The Sandbox: Modules run in a restricted environment to prevent abuse. Certain "admin" functions (underlined in docs) are restricted to the official Module Team .

The Loop: The eventLoop is the heart of any Transformice script, occurring every 500 milliseconds .

Tribal Houses: Most user-created scripts are tested and run in Tribal Houses before being submitted for "Official" status on the game's room list . A code template for a basic minigame module. A list of event IDs and color codes for UI development. Instructions on how to load and test scripts in-game. Lua | Transformice Wiki | Fandom

a player presses a key. eventLoop. Int currentTime, Int timeRemaining. This event occurs every 500 miliseconds (0.5 seconds). Transformice Wiki·Contributors to Transformice Wiki

An API that provides access to the game Transformice. · GitHub

Mastering the Transformice API: A Comprehensive Guide for Developers

Transformice, the physics-based multiplayer platformer, has fostered a dedicated community of creators for over a decade. At the heart of this creativity lies the Transformice API, a set of tools and protocols that allow developers to build everything from Discord bots and stat trackers to custom game modules.

Whether you are a seasoned coder or a curious player looking to automate your tribe’s ranking system, understanding how to interact with the game’s data is the first step toward building something impactful. What is the Transformice API?

The "API" for Transformice isn't a single RESTful endpoint like you might find with Twitter or Spotify. Instead, it is a collection of community-driven libraries and official socket-based protocols that allow external programs to communicate with the game servers. Key Capabilities

Real-time Interaction: Read chat logs, track player movements, and monitor room events.

Player Statistics: Fetch cheese gathered, firsts, shaman saves, and boot camp completions.

Module Development: Create custom mini-games within the Transformice ecosystem using Lua.

Tribe Management: Automate greetings, track member activity, and manage ranks via external bots. The Core Building Blocks

To work with the Transformice API, you generally need to choose between two paths: Lua Modules (internal) or Socket Clients (external). 1. Lua API (In-Game Modules)

If you want to create a game mode (like Racing, Survivor, or Defilante), you use the built-in Lua engine. Environment: Runs directly on the game server.

Access: Requires "Module Team" approval for official listing, but anyone can run scripts in private rooms.

Limitations: Restricted file I/O and limited networking to prevent security risks. 2. TFM-Lib and Python/Node.js Wrappers

For external applications (like Discord bots), developers use libraries that "mimic" a game client. TFM.js (Node.js): A popular choice for web developers.

Aioptfm (Python): An asynchronous library perfect for high-performance bots.

Functionality: These libraries handle the complex handshake and packet encryption required to talk to the Atelier 801 servers. How to Get Started

If you’re ready to dive in, follow these fundamental steps to set up your first project. Step 1: Secure Your API Credentials

To prevent abuse, Atelier 801 requires an API Key for certain types of data requests, especially when using the official "Crouton" service or community-run databases like MicePix. Step 2: Choose Your Language

For Data Analysis: Use Python. It’s excellent for scraping leaderboards and generating graphs of player growth.

For Live Bots: Use JavaScript/Node.js. The event-driven nature of JS makes it ideal for responding to in-game chat instantly. Step 3: Understand the Packet System

Transformice communicates using identifiers (low-level codes). For example, a specific code tells the server "I jumped," while another says "I typed in chat." Learning to parse these packets is what separates a novice from an expert API developer. Popular Community Projects Using the API

The best way to see the API in action is to look at existing tools: Retrieve game data : Access information about players,

Cheese.formice.at: The definitive source for global rankings and player history.

TFMBot: A versatile Discord bot that bridges the gap between your tribe's chat and your Discord server.

MiceForce & Private Servers: While technically separate, these projects often reverse-engineer the API to create entirely new experiences. Best Practices and Ethics

When using the Transformice API, it is crucial to follow the Atelier 801 Terms of Service:

Don't Spam: Ensure your bot doesn't flood the game servers with unnecessary packets.

Data Privacy: Never use the API to harvest private player information or passwords.

Stay Updated: Transformice frequently updates its encryption. Join developer forums like the Transformice Discord (TFM-Dev) to stay informed about breaking changes. Conclusion

The Transformice API is a gateway to enhancing the game experience for thousands of players. Whether you're building a competitive leaderboard or a fun social bot, the tools are at your fingertips. Start small—perhaps a bot that announces when a friend logs in—and gradually work your way up to complex game modules.

If you’re interested in building a specific tool, let me know! I can help you with:

Python or JavaScript code snippets for connecting to the server. Explaining specific Lua functions for in-game maps.

Finding the latest community libraries that are currently maintained.

Transformice!

The Transformice API, also known as the Transformice Web API, is a set of programming interfaces provided by Atelier 801, the creators of Transformice, to allow developers to access and interact with the game's data and features. Here's an overview:

What is Transformice? Transformice is a popular online multiplayer game where players control a mouse-like character, navigating through levels to reach a piece of cheese. The game has a strong focus on community features, such as user-generated levels, tribes, and leaderboards.

API Overview The Transformice API allows developers to:

1. Retrieve game data: Access information about players, levels, tribes, and other game-related data.
2. Create and manage levels: Develop and manage user-generated levels using the API.
3. Interact with game features: Use API endpoints to perform actions, such as sending messages, managing tribes, or updating player profiles.

API Endpoints The Transformice API provides a range of endpoints, including:

• Player endpoints: Get player information, such as profile data, level progress, and tribe affiliation.
• Level endpoints: Retrieve level data, create new levels, or update existing ones.
• Tribe endpoints: Manage tribe data, such as creating new tribes or updating tribe information.
• Message endpoints: Send and retrieve messages between players.

API Documentation Atelier 801 provides official API documentation, which includes:

• API endpoint descriptions
• Request and response formats (e.g., JSON)
• Authentication methods
• Rate limiting and usage guidelines

Authentication To use the Transformice API, you'll need to obtain an API key or authenticate using OAuth. This ensures that only authorized applications can access and modify game data.

Community and Resources The Transformice community is active and creative, with many developers creating custom tools, bots, and integrations using the API. You can find:

• API tutorials and guides: Community-created resources to help you get started with the API.
• API libraries and wrappers: Pre-built libraries for various programming languages to simplify API interactions.
• Forums and discussion groups: Official Transformice forums and community groups where you can ask questions and share knowledge.

Getting Started If you're interested in using the Transformice API, start by:

1. Reading the official API documentation
2. Obtaining an API key or setting up OAuth authentication
3. Exploring community resources and tutorials

Have fun exploring the world of Transformice and creating your own projects with the API!

Practical Uses of the Web API

• Discord Bots: Bots like "Transformice Info" use scraped data to display a player’s mouse color, tribe, and event trophies directly in a Discord server.
• Stat Trackers: Websites like TfmStats (now defunct) or CheeseTrack aggregated historical data from thousands of players to show win/loss ratios over time.
• Tribe Management: External tools that list all tribe members, their last login dates, and activity levels to help leaders prune inactive users.

Note: Because these endpoints are unofficial, they are fragile. A single game update from Atelier 801 can break every bot and website relying on them.

3. system (The Event Listener)

This is where you hook your code into the game engine flow.

• eventNewPlayer(name): Triggered when a mouse joins.
• eventPlayerDied(name): Triggered on death.
• eventPlayerCheese(name): Triggered when cheese is collected.
• eventLoop(progress, time): Triggered every frame (1/30th of a second), used for physics calculations.

3.1 Authentication Flow

| Step | Direction | Message | Description | |------|-----------|---------|-------------| | 1 | C → S | v2 | Protocol version handshake | | 2 | S → C | HELLO | Server ready | | 3 | C → S | a[username] | Login with username (no password – legacy) | | 4 | S → C | l | Login accepted | | 5 | C → S | p[community] | Select community (en, fr, br, etc.) | | 6 | S → C | K | Ready to join rooms |

Note: Modern web clients use token-based auth via at801_sid cookie. The socket flow remains similar.

1. Executive Summary

Transformice is a flash-turned-HTML5 multiplayer puzzle-platformer. Atelier 801 has never released an official external API. However, the game operates over a persistent socket connection (XMLSocket/WebSocket) using a proprietary text-based protocol. Community developers have reverse-engineered this protocol to create:

• Bots (automated players)
• Room managers (moderation tools)
• Stat trackers (titles, mice, cheese counts)
• Discord integrations

This report documents the known message formats, authentication flow, and practical usage.

What the API Enables

1. Completely New Game Modes: The API allows scripters to turn Transformice into a racing game, a PvP arena, or a logic puzzle solver.
2. Anti-Griefing Tools: Module creators can use the API to track player actions and automatically kick or mute trolls.
3. Economy Systems: Advanced scripts use system.loadFile and system.saveFile to create persistent player currencies within a room.

3. The Unofficial Web API: Connecting the Game to the World

Since Atelier 801 (the developer) has not released an official REST API for developers, the community built its own tools. Using network sniffing and public data endpoints, the Transformice Web API was born.

Technical Analysis Report: Transformice API Ecosystem

Date: April 20, 2026
Subject: Reverse-engineered API structure, event protocol, and integration methods for the game Transformice (Atelier 801)

What Is the Transformice Lua API?

At its core, the Transformice API is a Lua scripting interface designed for players in "survival" and "vanilla" custom rooms. When a player becomes the Shaman, they can write scripts that spawn objects (planks, bubbles, anchors, etc.) and control physics in real-time.