How to Use the Import Macros Action to Build Reusable Macro Packs

If you have ever rebuilt the same automation on a second phone, helped a family member set up the same routine, or lost a carefully tuned macro after a factory reset, you already understand the problem this guide solves. Building macros one by one is satisfying the first time, but it becomes slow, error-prone work the moment you need the same behaviour in more than one place. MacroDroid’s Import Macros action turns a finished set of macros into a reusable pack: a small, portable bundle you can install, update, and share without retyping every trigger, action, and constraint.

A macro pack is not just a backup file. A backup restores everything at once, which is useful after a reset but clumsy when you only want one routine. A pack is selective. You might bundle a bedtime routine, a driving mode, and a low-battery saver into one work pack, and keep a separate family pack with a morning alarm routine and a medication reminder. Each pack can travel on its own, be installed on a different device, and be improved over time without disturbing the rest of your setup. That separation is what makes packs so valuable for people who manage more than one phone, or who regularly help friends and relatives get started with automation.

This guide walks through the whole process in plain language. You will learn how to prepare macros so they import cleanly, how to use the Import Macros action inside a larger setup macro, how to test a pack safely, and how to fix the common problems that appear when a pack lands on a phone with different apps, permissions, or settings. No programming experience is needed, and everything here uses only the official MacroDroid app and its built-in export and import features.

Prerequisites

Before you build a pack, check that you have a few basics in place. First, you need MacroDroid installed on both the phone that creates the pack and any phone that will receive it. The versions do not have to match to the day, but a very old version may not understand a macro built with a newer feature, so updating MacroDroid on both devices before you start will save you a confusing error later. Second, decide which macros belong in the pack and give them clear, descriptive names. A macro called “Macro 7” tells nobody anything; a macro called “Bedtime – Silence and Dim Screen” tells the next person exactly what it does.

Third, think about dependencies. If a macro launches a specific app, sends a message to a specific contact, or writes to a specific folder, the receiving phone needs that app, that contact, or that folder, or the macro will need a quick edit after import. Make a short note of these dependencies while you are still on the source phone. Fourth, check permissions. Macros that change system settings, read notifications, or control Do Not Disturb need the matching permissions granted on the receiving device, and Android will ask for them again after import. That is normal, and it is a security feature, not a fault in your pack.

Finally, plan where your pack file will live. You can keep it in a shared folder on the device, send it through a messaging app, or store it in your own cloud storage for your own use. The method matters less than keeping one master copy that you update deliberately, rather than several slightly different copies scattered across chats and downloads folders.

Step-by-Step Setup

Step 1: Clean up the macros you want to pack

Open MacroDroid and open the first macro you plan to include. Read through its triggers, actions, and constraints as if you were explaining it to someone else. Remove any test actions you added while experimenting, such as a temporary notification that says “test”, and delete any constraint that only made sense on your old phone, such as a constraint tied to a Wi-Fi network you no longer use. Repeat this for every macro in the pack. A clean source macro imports cleanly; a messy one imports its mess along with it.

While you are cleaning up, check for personal details that should not travel with the pack. A macro that texts your home address, dials a private number, or opens a work system may be perfect for your own phone but wrong for a shared pack. Either generalise it, for example by replacing a specific number with a placeholder you explain in a note, or leave that macro out of the shared version and keep a private version for yourself.

Step 2: Export the macros as a pack file

MacroDroid lets you export macros from the macro list. Select the macros you want to include, choose the export option, and save the resulting file with a clear name that includes a version, such as “Family-Morning-Pack-v1”. The version number matters because packs evolve. When you fix a bug or add a feature, saving the new file as version two prevents confusion about which file is current. Keep the master file somewhere you can find it again, and avoid renaming it casually, because a renamed file with no version history is how two different packs end up sharing one name.

If you are building a pack for your own second phone rather than for someone else, this exported file is already your pack. You do not need any special packaging tool. The file itself is the pack, and importing it on the other device is the next step.

Step 3: Create a setup macro that uses the Import Macros action

Here is where the Import Macros action earns its place. Instead of asking the recipient to find a file, open a menu, and import it by hand, you can build a single setup macro that does the importing for them. Create a new macro and give it a name such as “Install Family Pack”. For its trigger, use something deliberate and safe, such as a Shortcut Launched trigger or a Floating Button trigger, so the pack installs only when the person taps it, never by accident in the background.

For the action, add Import Macros and point it at your pack file. Take care with the file path: it must match where the file actually sits on the receiving phone. If you plan to send the file by chat, tell the recipient to save it to a specific folder first, such as the Downloads folder, and point the action at that folder. If the file will already be in a shared folder, point it there instead. Add a second action after the import, such as a Notification or a Display Dialog action, that says the pack has been installed and lists what to check next. That confirmation message is small, but it prevents the most common support question: “Did it work?”

Add a constraint if it helps. For example, a constraint that the setup macro only runs when the pack file exists prevents a confusing failure if the file was never saved. You can also add a second macro, or a second action, that opens MacroDroid’s macro list afterwards, so the recipient can see the newly imported macros with their own eyes.

Step 4: Import the pack on the receiving device

On the receiving phone, save the pack file to the folder your setup macro expects, then run the setup macro by tapping its shortcut or floating button. MacroDroid will import the macros and show them in the macro list. If you are importing by hand instead, open the macro list, choose the import option, select the file, and confirm. Either route ends in the same place: the pack’s macros appear alongside any macros already on the phone.

Do not be surprised if MacroDroid asks about duplicate names. If a macro with the same name already exists, it will usually ask whether to replace it or keep both. Replacing is right when the pack is an update to a macro the person already has; keeping both is safer when you are unsure, because you can compare the two versions and delete the older one later. When in doubt, keep both and tidy up afterwards.

Step 5: Grant permissions and fix device-specific details

After import, open each imported macro and check the items that depend on the individual phone. Grant any permissions Android requests, such as notification access, Do Not Disturb access, or accessibility access, by following the on-screen prompts. Re-link any app-specific actions if the receiving phone uses a different app for the same job, for example a different messaging app or a different music player. Update any contact, folder, or device name that differs. This step usually takes only a few minutes, and it is the difference between a pack that looks installed and a pack that actually works.

Testing and Verification

Test one macro at a time, starting with the least disruptive one. If your pack includes a macro that silences the phone at night and another that sends a message, test the silencing macro first, because a failed message macro is merely annoying while a message sent to the wrong person is embarrassing. For each macro, trigger it deliberately using its real trigger if that is safe, or use MacroDroid’s test option to run it on demand. Watch for the expected result: the screen dims, the volume changes, the notification appears, or the app launches.

Keep a simple checklist as you test. Write down each macro name, whether it worked first time, and any fix you applied. That checklist becomes your release note for version two of the pack, and it helps the next person who installs it, because they will know which macros needed a tweak on a different phone model. After individual tests pass, leave the pack running for a day under normal conditions. Some problems only appear at a real trigger time, such as a morning alarm macro that works when tested at noon but fails at seven in the morning because a battery optimisation setting has put MacroDroid to sleep overnight.

Check the system log inside MacroDroid if anything behaves oddly. The log shows which macros fired, when, and whether any action failed. A failed action usually has a clear reason in the log, such as a missing permission or an app that was not found, and that reason points directly at the fix.

Troubleshooting

The most common import problem is a file that cannot be found. This almost always means the file path in the Import Macros action does not match where the file actually is on the receiving phone. Confirm the folder, check for a renamed file, and remember that some chat apps save downloads to their own folder rather than the main Downloads folder. Moving the file to the expected folder and running the setup macro again usually solves it immediately.

The second common problem is a macro that imports but does nothing. Check permissions first, then battery optimisation. Android’s battery settings can stop MacroDroid from running in the background, which silently kills time-based and event-based triggers. Excluding MacroDroid from battery optimisation, following the guidance in the app itself, fixes a large share of these cases. Also check that the macro is enabled: an imported macro can arrive disabled, and a disabled macro will never fire, no matter how correct it looks.

A third problem is an action that references something the new phone does not have. A macro that launches an app that is not installed will fail at that step, and a macro that writes to a folder that does not exist will do the same. The fix is to install the app or create the folder, or to edit the action to point at the equivalent item on the new phone. This is why noting dependencies before you export saves so much time later.

If a macro behaves differently after import, compare it side by side with the original. A constraint that made sense on the source phone, such as a particular Bluetooth device being connected, may be blocking the macro on the new phone. Removing or updating that one constraint often restores the expected behaviour without any deeper change.

Tips for Better Macro Packs

Keep packs small and focused. A pack with three macros that all serve one routine is easier to understand, test, and update than a pack with twenty unrelated macros. If your collection grows, split it into themed packs rather than letting one giant pack accumulate. Version your packs, and keep a short note with each version saying what changed. When someone reports a problem, the first question is always which version they installed, and a version number answers it instantly.

Document the pack in plain language, even if it is only a few lines at the top of your setup macro’s confirmation message. List what each macro does, what permissions it needs, and what the user should check after installing. That documentation is what turns a file you understand into a pack anyone can use. Finally, test your pack on a second device before you share it widely. The five minutes that test takes will catch the path errors, permission gaps, and missing apps that are invisible on the phone where the pack was built.

Reusable macro packs reward the small amount of discipline they require. Build cleanly, version clearly, test honestly, and the next phone you set up, or the next person you help, will get in minutes what took you an afternoon to perfect the first time.

Frequently Asked Questions

What exactly does the Import Macros action do?

It imports macros from a MacroDroid export file into the phone it runs on, so the recipient does not have to import the file by hand. It is most useful inside a setup macro that also shows a confirmation message afterwards.

Can I import a pack if I already have macros with the same names?

Yes. MacroDroid will normally ask whether to replace the existing macro or keep both. Keeping both is the safer choice when you are unsure, because you can compare the versions and delete the older one later.

Why does an imported macro not fire?

The usual causes are missing permissions, battery optimisation stopping MacroDroid in the background, or the macro arriving disabled. Check those three things first, then check the system log for a failed action.

Do pack files work between different phone brands?

In most cases, yes, as long as both phones run a compatible MacroDroid version and have the apps and permissions the macros need. Device-specific details, such as a particular Bluetooth device or folder, may need a quick edit after import.

Is it safe to import a macro pack someone else made?

Only import packs from people you trust, and read through each imported macro before enabling it. A macro can send messages, change settings, or share information, so you should understand what every macro in a pack does before you let it run.

Leave a Comment