Android apps talk to each other through intents: small, structured messages that say “open this”, “play that”, or “do this with these details”. MacroDroid’s Send Intent action lets your macros join that conversation, triggering features in other apps that have no ordinary button or shortcut. The real power appears when you combine intents with Magic Text — MacroDroid’s way of inserting live values, such as the current time, a variable, or device information, directly into the intent. When even the parameter names themselves can contain Magic Text, an intent stops being a fixed message and becomes a flexible template that adapts to the moment. This guide explains intents plainly, shows how to build a dynamic intent safely, and warns you about the mistakes that make intents fail silently.
Intents sound technical, but the idea is everyday: you are handing another app a labelled parcel. The action tells the app what kind of job this is, the target tells it which app or component should receive it, and the extras — the parameters — carry the details. A music app might accept an intent with a “track” parameter; a home app might accept one with a “room” and a “state” parameter. Magic Text lets those details change at run time: the track becomes today’s playlist choice, the room becomes wherever you are, the state becomes on or off depending on a variable. Learning this pattern opens up integrations that no trigger menu lists, because you are speaking the app’s own language.
Prerequisites
You need MacroDroid with the Send Intent action, plus a receiving app that actually accepts custom intents and documentation — or at least a known example — of what that app expects. Never guess an intent’s parameters blindly and fire it at a system app; start with a harmless, well-documented example, such as a media or home-control app that publishes its intent interface. You should be comfortable with MacroDroid variables and Magic Text basics, because dynamic parameter names build directly on those skills. Decide exactly what you want the intent to achieve, write down the action, target, and parameter names from the receiving app’s documentation, and note which values should be fixed and which should come from Magic Text. Back up your macros before experimenting, since a mistargeted intent can, in rare cases, trigger an unintended action in another app.
A word of caution belongs here before any steps: only send intents to apps you trust, only with parameters you understand, and never use intents to bypass an app’s own permissions, locks, or payment screens. Intents are a legitimate integration tool, not a way around another app’s rules. If an app’s documentation does not describe an intent, treat that as a sign to use its normal interface instead.
Step-by-Step Setup
Step 1: Learn the receiving app’s intent contract
Before opening MacroDroid, find the receiving app’s intent documentation or a trusted example. Note the action string, the package or component name if required, the type of intent (broadcast, activity, or service), and every parameter name with its expected value type — text, number, or true-or-false. Copy these names exactly; intent parameters are case-sensitive, and a misspelled parameter is silently ignored rather than reported as an error. If the documentation gives an example, replicate that example exactly first, with fixed values and no Magic Text, so you have a known-good baseline. Only when the fixed version works should you make anything dynamic.
Step 2: Build a fixed intent and test it
Create a test macro with a manual trigger and add a Send Intent action. Fill in the action, target, and parameters exactly as documented, using fixed values throughout. Run the macro and confirm the receiving app responds as expected — the track plays, the light changes, the screen opens. If nothing happens, check the action string and target first, then each parameter name, then the intent type; most failures are spelling or type mismatches, not deep mysteries. Keep this fixed version saved as a reference macro, because it is the version you will compare every dynamic experiment against. A dynamic intent that fails is debugged by returning to this fixed baseline.
Step 3: Replace a parameter value with Magic Text
Now replace one parameter value — not a name yet — with Magic Text. For example, if a parameter called “message” previously held fixed text, replace it with a variable that holds today’s reminder text, or with the current time. Run the macro and confirm the receiving app receives the dynamic value correctly. This step teaches you how Magic Text resolves at run time and what happens when a variable is empty: test the empty case deliberately, because an empty value sent to another app can produce odd behaviour. Add a guard if needed, such as only sending the intent when the variable is not empty. Change one value at a time, testing after each change, so you always know which change caused a failure.
Step 4: Put Magic Text in a parameter name
Here is the distinctive technique this guide is about. Some integrations need the parameter name itself to vary — for instance, an app that accepts parameters named after a device, a room, or a user-selected option, where the name is only known at run time. In the Send Intent action, enter Magic Text in the parameter name field, such as a variable holding the current room name, so the outgoing intent carries a parameter whose name is decided when the macro runs. Test this with two different variable values and confirm the receiving app responds differently to each, proving the name truly varied. Keep a log of what names were sent during testing, because a dynamic name that varies invisibly is hard to debug from the receiving side alone.
Step 5: Validate names before sending
Dynamic names introduce a new failure mode: an unexpected variable value creates a parameter name the receiving app does not recognise, and the intent is silently ignored. Protect against this with validation. Before the Send Intent action, check that the variable holds one of a short list of allowed names — for example, only “living_room”, “bedroom”, or “kitchen” — and stop safely with a notification if it holds anything else. This allow-list turns a silent failure into a visible, diagnosable one. Also sanitise the value: strip spaces and unusual characters that could break a parameter name, and keep names short and lowercase unless the receiving app documents otherwise. Validation is not bureaucracy; it is the difference between a reliable integration and a mysterious one.
Step 6: Move from test macro to daily macro
Once the dynamic intent works with several values, replace the manual trigger with your intended trigger — a time, a location, a scene button, or another macro’s result — and add the constraints that make it safe for automatic use, such as a time window or a “only when at home” condition. Test the full chain end to end, including the trigger, the validation, and the receiving app’s response. Rename the macro to describe its real purpose, document the allowed parameter names in its description, and keep the fixed reference macro for future troubleshooting. Review the macro after a receiving-app update, because updates sometimes change intent interfaces without fanfare.
Testing and Verification
Test the intent with each allowed dynamic name, with a disallowed name (confirming it stops safely), with an empty variable (confirming it does not send a broken intent), and with the receiving app closed and open. Test after a restart and with the phone locked, since background intent delivery can differ in those states. Confirm the receiving app’s response in the real world each time, not merely that MacroDroid reports the action as run — an intent can be “sent” successfully yet ignored by its target. Keep a test log of names sent and responses observed until the pattern is stable.
Troubleshooting
If a fixed intent fails, recheck spelling, case, intent type, and target against the documentation, and confirm the receiving app version still supports that intent. If a dynamic value fails while the fixed version works, inspect the resolved value at run time — display it in a notification before sending — because the variable often holds something slightly different from what you assumed, such as extra spaces. If a dynamic name fails, verify the allow-list, check for illegal characters, and confirm the receiving app actually varies its behaviour by parameter name rather than by value. If the intent works manually but not automatically, check triggers, constraints, and battery optimisation. If an intent ever triggers an unintended action, disable the macro immediately, review its parameters, and do not re-enable it until you understand exactly what was sent.
Tips
Document every intent you send: action, target, allowed parameter names, and example values, in the macro’s description. Prefer documented intents over reverse-engineered ones, because documented interfaces are stable and supported. Keep dynamic names to a small allow-list, and prefer dynamic values over dynamic names unless the receiving app genuinely requires a varying name. Test intents after every receiving-app update. Finally, respect the receiving app’s design: an intent is a request to another app, not a command over it, and a well-behaved macro sends requests the other app is designed to honour.
Frequently Asked Questions
What is a custom intent in MacroDroid?
A custom intent is a structured message your macro sends to another app through the Send Intent action, carrying an action, a target, and parameters that tell the receiving app what to do.
What is Magic Text?
Magic Text inserts live values — variables, device information, time, and more — into a macro’s fields at run time, so an action’s details can change each time the macro runs.
Why put Magic Text in a parameter name, not just its value?
Some apps vary their behaviour by parameter name itself, such as naming a parameter after a room or device. When the name is only known at run time, Magic Text in the name field lets the macro build the correct parameter dynamically.
Why is my intent silently ignored?
The usual causes are a misspelled action or parameter name, a wrong intent type, or a parameter the receiving app does not recognise. Intents rarely report these errors, so verify names against documentation and test from a fixed baseline.
Is sending intents to other apps safe?
Yes when you use documented intents in trusted apps, with parameters you understand, and with validation on dynamic values. Never use intents to bypass another app’s permissions, locks, or payment screens.


