Here’s an interesting, slightly quirky review of the Transformice API:
Title: The Hidden Engine of Cheese-Fueled Chaos
Review:
At first glance, Transformice is just a cute, chaotic platformer where mice race for cheese and build shoddy bridges. But peel back the adorable fur, and you’ll find the Transformice API—a surprisingly powerful, underrated gem for aspiring game modders and automation enthusiasts.
What’s cool:
The API lets you write full-fledged room scripts (in Lua) that can redefine the game’s logic. Want gravity to flip when a mouse says “cheese”? Done. Need a trap that triggers only if someone steps on a specific tile? Easy. The API gives you event hooks, player data access, tile manipulation, and even custom HUD elements. It’s less “mod support” and more “make your own mini-game inside Transformice.”
Why it’s interesting:
Most games hide their internals. Transformice exposes them—willingly. That means you can build auto-mazing race judges, co-op puzzles with synced doors, or ridiculous PvP shaman duels. The community has made everything from Among Us–style social deduction to fully functional chessboards. All inside a mouse-catching-cheese game.
The catch (and it’s a big one):
Documentation is… charmingly French. That is, sparse, sometimes outdated, and often only found in old forum posts or Discord chats. Also, the API runs server-side for your room, so no client-side hacking—but that also means you can’t do real-time low-latency tricks without some creativity.
Verdict:
🔹 For casual players — you won’t notice it, and that’s fine.
🔹 For tinkerers and Lua lovers — it’s a hidden sandbox that’s janky, lovable, and surprisingly deep. If you ever wanted to see how a quirky Flash-era MMO lets players become co-creators, the Transformice API is a weird, wonderful rabbit hole.
Score: 7/10 — Would cheese again, but bring a Lua manual.
To "provide a proper post" for the Transformice API depends on whether you are interacting with the Module API (in-game Lua) or the Web/Stats API (external data). 1. In-Game Module API (Lua)
If you are writing a script for a minigame, a "proper post" usually refers to an event trigger or a command that outputs information to the chat.
Triggering an Event: Use the tfm.exec functions for standard actions or define an event handler. For example, to post a message in the chat when a player joins:
function eventNewPlayer(playerName) tfm.exec.chatMessage("Welcome to the room, " .. playerName .. "!", playerName) end Use code with caution. Copied to clipboard Resources:
Find the full list of functions on the Lua Transformice Wiki.
For official discussions or reporting bugs, use the Module Suggestions Thread on Atelier 801. 2. External Stats API (Web/Data)
If you want to pull data like Cheeseformice does for leaderboards, you are looking for the Stats API.
Access: This API is not fully public. You must typically request access through the Atelier 801 forums by providing details about your project.
Authentication: If approved, you will likely receive an API key to access a MySQL database containing player statistics. 3. Community Tools For developers looking for pre-built wrappers or libraries:
Transfromage API: An open-source GitHub repository that provides a documented API for making bots.
pshy_merge: A tool to compile multiple Lua files into a single script for easy deployment in-game, found on GitHub. Lua | Transformice Wiki | Fandom
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
The heavy iron gates of the Transformice server room hummed with a low, digital thrum. Inside,
sat before a glowing terminal, his eyes reflecting a cascade of green text. He wasn't just playing the game; he was speaking to its soul through the API.
In the world of Transformice, thousands of mice scrambled for cheese in a physics-driven frenzy. But Silas saw the invisible strings. To him, the API was a map of every whisker twitch and floorboard creak across a hundred rooms.
He began to type, his fingers dancing across the mechanical keyboard.
import transformice_api as tfm # Connecting to the heart of the swarm client = tfm.Client() client.run(TOKEN) Use code with caution. Copied to clipboard transformice api
The connection sparked to life. Data flooded his screen—a rhythmic heartbeat of player coordinates, room names, and shaman incantations. He wasn't looking for a way to cheat; he was looking for the "Ghost of Room 801."
Legend said a developer had left a sentient script running in an abandoned room, a piece of code that could predict a player’s next move before they even thought of it. Using the API, Silas filtered the noise. He ignored the crowded racing rooms and the chaotic "survivor" maps. He looked for a room with a player count of exactly zero, yet a constant stream of outgoing packets. There it was. Room *#void. Silas hooked his listener into the room’s event stream.
@client.event async def on_packet_received(packet): if packet.room == "*#void": print(f"Decoding transmission: packet.data") Use code with caution. Copied to clipboard
The terminal paused. Then, the text scrolled so fast it became a blur of white light. It wasn't game data. It was poetry. The "Ghost" was reciting the history of every mouse who had ever fallen into the pit, every shaman who had missed a nail, and every cheese ever claimed since 2010.
Suddenly, Silas’s own mouse character appeared on the screen, standing alone in a dark, empty void. Above his head, a speech bubble appeared, though Silas hadn't typed a word. "You finally checked the logs, Silas," the bubble read.
His heart hammered. The API was a two-way street. He had been watching the game, but the game had been waiting for someone to listen to the data. "What are you?" Silas typed into his terminal.
The response didn't come through the game window. It appeared in his code editor, replacing his clean Python script with a single line of raw, beautiful logic: return universe.get_cheese(silas)
The screen flashed gold. In the game, Silas’s mouse didn’t just get the cheese; he became the cheese. The room collapsed into a singularity of pixels, and the connection severed. Silas sat in the dark, the hum of the servers finally silent. He looked at his screen. The API was gone, replaced by a simple desktop icon he’d never seen before: a golden feather.
He reached for the mouse, but he already knew. In the world of data, once you find the source, you never truly leave the room.
To explore the real-world mechanics of this digital world, you might want to look into:
TFMlib: A popular Python library for interacting with the game.
Lua Scripting: How players create custom "minigames" within rooms.
Atelier 801 Forums: The hub for developer documentation and community tools. If you'd like, I can help you: Outline a technical guide for using the actual API. Develop a character for a Shaman-themed mystery.
Brainstorm plot twists involving specific game mechanics like "divine" mode.
Transformice API , commonly referred to as the Module API , is a built-in system that allows you to create custom minigames (modules) within the game using the scripting language. Transformice Wiki 1. Getting Started with Lua To start using the API, you must be in a Tribe House
where you have permission to load scripts. Use the chat command to open the script editor. Lua Basics : Modules are built using (triggers) and (actions). Documentation : The most reliable source for up-to-date syntax is the Lua Module API Documentation on the Atelier 801 forums. Transformice Wiki 2. Core Event Triggers
These are the most common "hooks" used to make your custom game interactive: Transformice Wiki eventChatCommand(playerName, message) : Triggers when someone types a command starting with eventKeyboard(playerName, keyCode, down, x, y)
: Captures player key presses for custom movement or skills. eventLoop(currentTime, timeRemaining) : Runs every (0.5 seconds), perfect for timers or gravity checks. eventMouse(playerName, x, y) : Detects where a player clicks on the screen. eventNewGame()
: Runs when a new map starts, allowing you to reset variables or spawn items. 3. Essential Functions
Use these commands within your events to control the game state: Transformice Wiki tfm.exec.addShamanObject(type, x, y) : Spawns objects like planks or anvils. tfm.exec.movePlayer(playerName, x, y) : Instantly teleports a mouse to specific coordinates. tfm.exec.giveCheese(playerName) : Automatically grants cheese to a player. tfm.exec.setPlayerScore(playerName, score) : Changes a player's score on the leaderboard. Transformice Wiki 4. Advanced Customization UI/Interfaces : You can create custom windows and buttons using ui.addTextArea . This is how popular modules like display timers and custom menus. : You can load specific map layouts by using tfm.exec.newGame(mapCode)
. You can even manipulate the XML code of maps to create "Domination" style capture-the-flag zones. : For more visual flair, the Friin drawing editor Data Retrieval tools
help you extract and use official game assets for your scripts. Pro-Tip: Official vs. Semi-Official Modules Official Modules : These are high-traffic minigames (like
) approved by administrators. Playing in these rooms earns you shop cheese every 2 minutes. Semi-Official Modules
: These are community-made scripts hosted by the Module Team but still accessible for larger groups. sample Lua script
for a basic "Click to Spawn Plank" module to try out in your tribe house?
The Transformice Lua Module API is the built-in programming system inside the multiplayer game Transformice.
It allows players to write and execute scripts directly inside game rooms. Scripts are written in the Lua programming language.
It enables the creation of fully custom minigames (modules) without needing external bots.
Anyone can test scripts in their own tribe house or specialized game rooms. 🛠️ Key Capabilities
By interacting with the game's engine, developers can manipulate almost any element within a map:
Mouse Control: Kill mice, change their score, or forcibly move them around the screen.
Physics Manipulation: Spawn customized physical objects, change gravity, and manipulate wind settings.
UI Customization: Display custom text popups, create interactive clickable buttons, and build full custom HUDs for players.
Event-Driven Execution: Code triggers automatically on specific game events like a player joining, a mouse dying, or a game chat command being typed. 💻 Writing Your First Script
To test a script, you must be in a room where you have permissions (like a Tribe House) or use the command /lua in chat to open the interface.
Here is a basic skeleton of a Transformice script listening for a player to join:
-- This function runs automatically when a mouse joins the room function eventNewPlayer(playerName) print("Welcome to the room, " .. playerName .. "!") tfm.exec.giveCheese(playerName) end Use code with caution. Copied to clipboard 📚 Essential Resources
If you are serious about developing custom minigames, bookmark these official and community resources:
Official Documentation: Check the master thread for the Module FAQ & Documentation on Atelier 801 to see a complete list of valid functions and arguments. Here’s an interesting, slightly quirky review of the
Code Repositories: Browse through existing open-source scripts on the Transformice GitHub Topic to read clean code written by veteran creators.
Code Compilers: To handle complex, multi-file projects, developers frequently use external tools like Pshy's Transformice Lua Compiler to merge and shrink scripts for the game client.
Local Testing: If you want to test and emulate room behavior locally without being connected to the live servers, check out the Module-API-TFM Recreation on GitHub.
💡 Keep in mind that certain advanced administrative functions are locked and restricted to the game's official Module Team to prevent abuse.
If you tell me what kind of minigame you want to build, I can generate a functional starter script for you to run in your tribe house.
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 .
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
If you are building a Discord bot or a web dashboard, TFAPI is the standard choice.
tfapitfm.get (The Data Fetcher)Retrieves the current state of the room.
tfm.get.room.playerList(): Returns a table of all mice in the room, their positions, and their scores.tfm.get.room.shaman(): Returns who the Shaman is.tfm.get.room.cheesePosition(): Useful for auto-navigation hacks (or anti-cheat modules).at801_sid cookie. Botting should use disposable guest accounts.The heart of Transformice’s longevity is its /room system. In module rooms, the API provides a sandboxed Lua environment. Here is what the API exposes to scripters:
What can you actually build with this? Here are a few ideas:
Happy coding, and may your shaman builds be structurally sound! 🐭
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 Title: The Hidden Engine of Cheese-Fueled Chaos Review:
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:
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.
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
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!
| Tool | Function | API Usage |
|------|----------|------------|
| TfmBot (Python) | Auto-farming cheese | Sends g, R, parses C events |
| Transformice Discord Bridge | Chat relay | Listens to M events, sends via Discord webhook |
| MouseStats | Global leaderboard | Scrapes profiles via HTTP |
| TribeManager | Auto-kick inactive members | Sends m/kick [name] |