How to Bind Word Macro to a Specific Function Key Without Modifier

You want to run a Word macro by pressing a single function key like F8 or F11 without holding Ctrl, Alt, or Shift. By default, Word’s Customize Keyboard dialog requires you to press a key combination that includes at least one modifier key. This limitation means you cannot directly assign a macro to an unmodified function key through the standard user interface. This article explains the workaround using the Organizer to copy a macro into a template and then editing the Normal.dotm file with a simple VBA procedure to bind the macro to a bare function key. You will learn the exact steps to achieve this without third-party tools.

Why Word Cannot Assign a Macro to a Bare Function Key Through the UI

The Customize Keyboard dialog in Word is designed to accept key combinations that include at least one modifier key: Ctrl, Alt, or Shift. When you press a function key like F8 alone, the dialog registers it as an invalid shortcut and does not allow you to confirm the assignment. This behavior is by design to prevent accidental overwriting of built-in Word shortcuts such as F7 for Spelling & Grammar or F12 for Save As.

However, the underlying Windows keyboard messaging system does support binding macros to unmodified function keys. Word’s VBA environment exposes the Application.OnKey method, which can capture any key press including standalone function keys. The OnKey method runs a specified macro when a particular key is pressed, regardless of the dialog limitation. This method is the only built-in way to assign a macro to a bare function key in Word.

Before proceeding, ensure your macro is stored in a template that loads on startup, typically Normal.dotm. Macros stored in a single document will only work when that document is active. For a global assignment that works in any document, the macro must reside in Normal.dotm or another global template loaded via File > Options > Add-ins.

Steps to Bind a Macro to a Function Key Without Modifiers Using VBA

The following steps use the Visual Basic Editor to create an AutoOpen macro in Normal.dotm that assigns your custom macro to a specific function key. Word will run this AutoOpen macro each time it starts, establishing the key binding.

1. Open the Visual Basic Editor
   Press Alt+F11 to open the VBA editor. If the Project Explorer is not visible, press Ctrl+R to show it.
2. Locate the Normal template project
   In the Project Explorer, expand the node named “Normal” (Normal.dotm). If you do not see it, you may need to unhide it by clicking View > Project Explorer.
3. Insert a module for the AutoOpen macro
   Right-click “Normal” and choose Insert > Module. A new module named “Module1” appears. Double-click it to open the code window.
4. Write the AutoOpen macro
   Paste the following code into the module:

   Sub AutoOpen()
Application.OnKey Key:="{F8}", Procedure:="MyMacro"
End Sub

   Replace “{F8}” with the function key you want to use. Valid key codes are {F1} through {F12}. Replace “MyMacro” with the exact name of your macro. If your macro is in a different module, include the full module path: “ModuleName.MacroName”.

5. Write the macro that runs when the key is pressed
   In the same module or a different module, create the macro sub that does the work. For example:

   Sub MyMacro()
MsgBox "You pressed F8"
End Sub

   Save the file by pressing Ctrl+S or clicking the save icon.

6. Close Word and reopen it
   Exit Word completely, then start Word again. The AutoOpen macro runs automatically, binding the function key to your macro.
7. Test the key binding
   Press the function key you assigned. Your macro should execute. If nothing happens, check that the macro name in the OnKey line matches exactly and that the macro is stored in Normal.dotm.

The AutoOpen macro must be placed in the “Normal” project. If you put it in a document-specific project, the key binding will only work when that document is active. For a system-wide binding, the Normal.dotm template is the correct location.

If the Function Key Binding Does Not Work

The macro does not run when I press the assigned function key

First, verify that the AutoOpen macro runs on startup. Open Word, press Alt+F11, and check that the module containing AutoOpen exists under Normal. If the module is missing, you may have saved the macro in a different template or document. Recreate the module in the Normal project.

Second, ensure that the key code in the OnKey method matches the function key exactly. For F9, use “{F9}”. For F11, use “{F11}”. Do not include spaces or extra characters. The key code must be enclosed in curly braces.

Third, check that your macro name is spelled correctly. If the macro is in a different module, prefix it with the module name: “Module1.MyMacro”. If the macro contains an error, Word may display a runtime error or silently fail. Test the macro by running it manually from the Macros dialog (Alt+F8) to confirm it works.

Another Word function runs instead of my macro

Some function keys have built-in Word commands. For example, F7 opens the Spelling pane, and F12 opens the Save As dialog. When you use Application.OnKey to assign a macro to such a key, your macro overrides the built-in behavior only while the macro is active. If you want to restore the original function, call the original command inside your macro. For example, to restore F7’s spelling function after your macro runs, you can include Application.OnKey Key:="{F7}" at the end of your macro to reset it, or call the built-in command using Application.CommandBars.ExecuteMso "Spelling".

The key binding stops working after I close and reopen a document

This happens when the AutoOpen macro is stored in a document rather than in Normal.dotm. Document-level AutoOpen runs only when that specific document is opened. When you open a different document, the binding is lost. Move the AutoOpen macro to the Normal project to make it persistent across all documents.

OnKey Assignment vs Customize Keyboard Dialog: Key Differences

Item	OnKey Method (VBA)	Customize Keyboard Dialog (UI)
Function key without modifier	Supported	Not supported
Requires VBA knowledge	Yes	No
Persistence after restart	Requires AutoOpen in Normal.dotm	Automatic when saved to Normal.dotm
Can override built-in shortcuts	Yes	Yes, but only with modifier
Scope of binding	Global if in Normal.dotm	Global if saved to Normal.dotm

You can now assign any macro to a bare function key using the Application.OnKey method in VBA. Start by placing the macro in Normal.dotm, then write an AutoOpen macro that calls OnKey with the desired key code. If you need to assign multiple function keys, add multiple OnKey lines inside the same AutoOpen procedure. To remove a binding, set the Procedure argument to an empty string: Application.OnKey Key:="{F8}". This resets the key to its default behavior.