Transformice Api -
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?
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.
2. tfm.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).
3.3 Common Server → Client Events
| Event | Example | Meaning |
|-------|---------|---------|
| G[playerId] | G15 | Player joins room |
| L[playerId] | L15 | Player leaves |
| M[playerId][msg] | M15Hello | Chat message |
| P[id][x][y] | P1230 50 | Player position update |
| C[count] | C5 | Cheese count collected |
| S[code] | S1 | Shaman spell cast (1 = totem) |
| K | K | Round start / ready signal |
| E | E | Round end |
Short reference checklist
- Protocol type: binary socket/WebSocket
- Auth: account login, tokens/cookies
- Languages: Node.js, Python are common
- Common tasks: bots, stats, map tools, private servers
- Key concerns: rate limits, protocol version, ToS compliance
If you want, I can:
- Provide sample code (Node.js or Python) for connecting as a basic bot,
- List community GitHub projects and libraries (I can fetch recent links),
- Draft a small architecture for a stats-collection pipeline.
Which of those would you like next?
If you’re looking to dive into the Transformice (TFM) API , you're entering the world of Lua scripting
and bot development. While there isn't a single "official" developer blog, the community has built extensive resources to help you script everything from custom minigames to automated tribe bots.
Here is a breakdown of how the API works and where to find the best documentation. 1. The Core: TFM Lua API Transformice provides an internal
that allows players with "Module" permissions to create custom rooms and minigames. Creating scripts for rooms (like The API is event-driven . Your script waits for things like eventNewGame eventPlayerWon eventChatCommand Key Functions: tfm.exec.addShamanObject() : Spawns objects. tfm.exec.movePlayer() : Teleports mice. tfm.exec.setPlayerScore() : Updates the leaderboard. tfm.exec.displayParticle() : Adds visual effects. Where to learn: Official Lua Documentation
on the Atelier 801 forums is the definitive "blog-style" manual for these functions. 2. Networking APIs (Bot Development) If you want to create a
or a standalone application that talks to the game servers from outside the game client, you need a networking library. TFM.lua (Python/Node.js): Most modern bots use community-made libraries like or various Node.js implementations. Capabilities: transformice api
These bots can log in, join rooms, listen to chat, and moderate tribes automatically. Authentication: The bot connects to the Atelier 801 socket servers. Packet Handling:
It sends and receives "packets" (encoded data) to simulate a player's actions. 3. Data APIs (External Stats)
For web developers wanting to pull player stats or room info, there are community-driven endpoints. Cheese.formice:
This is the most famous third-party site for tracking player records and "cheese" statistics. API Usage:
While they don't always have a public REST API, many developers "scrape" or use community-shared database dumps from Atelier 801 Fansites How to Get Started Join a Module Team:
To run Lua scripts in-game, you often need to be in a room where you have permissions (like your Tribe House Use the Map Editor:
You can test Lua code directly in the game's Map Editor to see how objects interact. Check GitHub: Search for Transformice API on GitHub to find pre-made bot templates. If you'd like, I can help you with: basic Lua script to start a custom minigame. setup steps for a Python-based tribe bot. Explaining specific event handlers (like how to detect when a mouse grabs the cheese). Which path are you most interested in? Transformice: Tribe Bot Tutorial
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: Transformice API , commonly referred to as the
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 Title: The Hidden Engine of Cheese-Fueled Chaos Review:
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!
The Transformice API, primarily referred to as the Module API, is a Lua-based scripting system that allows players to create custom minigames (modules) directly within the game environment. Unlike external bots, these modules run natively on the game's servers, enabling developers to modify game physics, handle player interactions, and create unique objectives. Core Functionality
The API operates on an event-driven model, where specific Lua functions are triggered by in-game actions:
Player Input: eventChatCommand detects "!" commands in chat, while eventKeyboard and eventMouse track physical inputs.
Game State: eventNewGame triggers when a new map loads, and eventLoop runs every 500 milliseconds to handle continuous logic.
Interactions: Events like eventEmotePlayed allow scripts to respond to player animations. Types of Modules
Modules are categorized based on their status and accessibility:
Official Modules: Approved by Administrators and featured in the game's room list (e.g., #survivor or #racing). Players can earn shop cheese in these rooms.
Semi-Official Modules: Verified utilities or games that can be loaded in tribe houses but require a member of the Module Team to host them.
User Scripts: Custom scripts that players can run in their own private rooms or tribe houses for testing and casual play. Development Resources
Documentation: The official Module FAQ & Documentation on the Atelier 801 forums provides the standard starting point for developers.
Community Projects: Libraries like Transfromage provide external API access for bot development, though they require specific encryption tokens.
Shared Scripts: Many developers host ready-to-run scripts on GitHub, covering game modes from "Pacmice" to complex competitive variants. Getting Started
To begin coding, players typically use the /lua command in a room where they have permissions (like a tribe house) to paste and execute their scripts. For those looking for inspiration, the Transformice Wiki maintains an unofficial but detailed guide on event arguments and function descriptions. transformice · GitHub Topics
Transformice provides a few different ways to interact with its systems, primarily through its internal
for creating in-game content and unofficial external libraries for bot creation. 1. The In-Game Lua API
This is the official way to create custom game modes (Modules) or scripts for tribe houses. It uses a sandboxed version of Lua. Capabilities
: You can manipulate map physics, listen to player events (joining, chatting, dying), and spawn objects or projectiles. in your tribe house or use the Lua script editor provided by Atelier 801 Key Events eventNewGame() : Triggered when a new map loads. eventPlayerChat(name, message) : Monitors chat for specific commands. eventSummoningEnd(playerName, itemType, x, y) : Runs when a shaman finishes a summon. Official Documentation : The most up-to-date reference is usually the Module FAQ & Documentation on the official forums or the in-game 2. External Bot Development (Transfromage)
If you are looking to build an external tool (like a Discord bot that tracks player stats or a standalone client), the community-standard library is Transfromage
: It handles the low-level socket communication (packet encryption/decryption) required to talk to the Transformice servers. Maintenance : You can find various forks and updates on GitHub, such as Blank3495's Transfromage
, which often includes "autoupdate" features to keep up with game patches. 3. Requirements & Constraints
To run custom scripts successfully, you must meet certain in-game criteria: : Most custom Lua scripts must be executed in a Tribe House Permissions : You need the appropriate rank in your tribe to use the (Next Map) or Qualifications : Players generally need to have collected at least 100 cheese
and have a clean record (no active hack bans) to use these features. Draft Implementation Example (Lua) This simple script greets any player who joins the room: eventNewPlayer(playerName) tfm.exec.chatMessage( "Welcome to the room, " .. playerName .. , playerName) Use code with caution. Copied to clipboard or a guide on setting up a Python-based bot Lua | Transformice Wiki | Fandom
Step 2: Basic Bot Architecture
A minimalist bot in Python using a socket library:
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(("transformice.com", 10000)) # Port varies by language
Limitations & Challenges
- No Official REST API: You cannot query player profiles, leaderboards, or friend lists via a standard HTTPS request.
- Sandboxed Lua: The in-game Lua environment is restricted for security—no file I/O, no internet requests, and limited memory.
- Protocol Changes: Atelier 801 occasionally updates the game’s netcode, breaking third-party bots and unofficial APIs.
What is the Transformice API?
In the context of Transformice, the term "API" can refer to two distinct things:
- The Internal Lua API (Client-side): The set of functions, events, and callbacks provided by Atelier 801 to write modules (mods). These mods run inside the game client or on dedicated "Tribulle" (community) rooms.
- The External HTTP API (Server-side): Unofficial endpoints used by the game launcher, the website (
transformice.com), and mobile apps to fetch player stats, shop items, and friend lists.
Most developers searching for "Transformice API" are looking for the Lua API to create event-driven interactions. However, we will also cover the reverse-engineered REST API because it is essential for Discord bots and analytics tools.
4.2 Item Icons
GET https://transformice.com/images/items/[id].png
Example: id=3 → plank sprite