Step-by-Step Guide – How to Trigger GitHub Action Manually – A Comprehensive Tutorial


GitHub Actions is a powerful tool provided by GitHub that allows you to automate various tasks and workflows directly in your repository. By defining workflows using YAML files, you can configure actions to be triggered automatically based on events such as pushing code or creating pull requests. However, there are scenarios where you might want to trigger GitHub Actions manually. In this blog post, we will explore the process of manually triggering GitHub Actions and the benefits it can provide.


Before diving into manually triggering GitHub Actions, there are a few prerequisites you need to fulfill.

Setting up a GitHub repository

In order to utilize GitHub Actions, you need to have a repository set up on GitHub. If you don’t have one already, head over to GitHub and create a new repository. You can choose between creating a new repository from scratch or forking an existing one.

Enabling GitHub Actions

GitHub Actions need to be enabled for your repository in order to use them. To enable GitHub Actions, follow these steps:

  1. Go to your repository on GitHub.
  2. Click on the “Actions” tab.
  3. Click on the “Set up this workflow” button.
  4. Choose an existing workflow template or create a new one.
  5. Commit the changes to enable GitHub Actions.

Step-by-Step Guide to Manually Trigger GitHub Actions

Now that you have the prerequisites set up, let’s walk through the process of manually triggering GitHub Actions.

Step 1: Understanding workflow files

Before we can manually trigger actions, it’s important to understand the structure of workflow files. Workflow files are written in YAML format and define the actions, events, and triggers associated with a workflow. They are typically stored in the .github/workflows directory of your repository.

Explaining workflow files structure

A typical workflow file consists of a name, an on section that defines the events or triggers, and a series of jobs that specify the actions to be performed. Here is an example of a basic workflow file:

name: My Workflow
on: push: branches: - main
jobs: build: runs-on: ubuntu-latest steps: - name: Checkout code uses: actions/checkout@v2 - name: Build project run: | npm install npm run build 

Identifying triggers and events

Triggers and events are defined in the on section of a workflow file. Triggers are events that automatically trigger a workflow, such as pushing code or creating pull requests. By default, the push event is used to trigger workflows when code is pushed to the repository. However, we can also add manual triggers to allow for manual execution of workflows.

Step 2: Configuring manual triggers

Now that we understand the basics of workflow files, let’s explore how to configure manual triggers.

Adding workflow_dispatch field

To enable manual triggering of a workflow, we need to add the workflow_dispatch field to the on section of the workflow file. This field allows you to run the workflow manually from the Actions tab in your repository.

Defining inputs and outputs

You can also define inputs and outputs for your manual workflow triggers. Inputs allow you to specify parameters that can be provided when triggering the workflow, while outputs enable you to capture and use the output values of the workflow in subsequent steps or jobs.

Step 3: Creating a manual workflow

With the manual trigger configured, it’s time to create a manual workflow.

Writing the YAML code for the workflow

Start by creating a new YAML file in the .github/workflows directory of your repository. Give the file a descriptive name, such as manual-trigger.yml. Inside the file, define the name of your workflow and add the workflow_dispatch field to the on section.

name: Manual Workflow
on: workflow_dispatch:
jobs: build: runs-on: ubuntu-latest steps: - name: Checkout code uses: actions/checkout@v2 - name: Build project run: | npm install npm run build 

Specifying on which branch or event the workflow should run

You can also specify on which branch or event the workflow should run by adding additional conditions to the on section. For example, you can configure the workflow to only run on the main branch or when a specific event occurs.

Step 4: Testing the manual trigger

With the manual workflow created, it’s time to test the manual trigger.

Committing changes to trigger the action

To manually trigger the workflow, go to the Actions tab in your repository and click on the “Run workflow” button next to the manual workflow you created. This will open a form where you can provide any necessary inputs for the workflow.

Confirming successful workflow execution

After triggering the manual workflow, you can monitor its progress and view the output in the Actions tab. If everything is configured correctly, the workflow should run successfully and perform the desired actions.

Step 5: Customizing the manual trigger

Now that you have a basic understanding of manual triggering, let’s explore some customization options.

Adding additional parameters

You can add additional parameters to your manual workflow triggers by defining them in the workflow file. These parameters can be dynamically provided when triggering the workflow and can be used to modify the behavior of the workflow.

Modifying the workflow’s behavior

You can also modify the behavior of the workflow based on the inputs provided during manual triggering. For example, you can conditionally execute certain steps or jobs based on the input values.

Advanced Usage

In addition to manual triggering from the GitHub UI, there are advanced usage options available for manually triggering GitHub Actions.

Using GitHub API to trigger actions programmatically

The GitHub API allows you to trigger actions programmatically using various methods. One way is to use a cURL command to make a POST request to the GitHub API. The POST request should include the necessary information, such as the repository, workflow name, and inputs.

Example of triggering actions with cURL command

curl \ -X POST \ -H "Accept: application/vnd.github.v3+json" \ -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \ \ -d '{"ref": "main", "inputs": {"param1": "value1", "param2": "value2"}}' 

Integrating actions within external scripts or applications

You can also integrate the manual triggering of GitHub Actions within external scripts or applications. This enables you to incorporate the execution of workflows into your existing development processes or tools.

Automating manual triggers using webhooks

If you want to automate the manual triggering process even further, you can set up webhooks to trigger workflows.

Configuring a webhook for workflow_dispatch events

To set up a webhook, go to the settings of your repository on GitHub and click on the “Webhooks” section. Add a new webhook and configure it to trigger on the workflow_dispatch event. You can specify the URL of the external system that should receive the webhook payload.

Accomplishing automation with external systems

By configuring the webhook to send a payload to an external system, you can then implement custom logic to trigger the manual workflow based on the received payload. This allows you to automate the manual triggering process using external systems or services.


In this blog post, we have explored the process of manually triggering GitHub Actions. We discussed the prerequisites needed to get started, walked through a step-by-step guide to manually triggering workflows, and explored advanced usage options such as programmatically triggering actions and automating manual triggers using webhooks.

Manually triggering GitHub Actions provides flexibility and control over when and how workflows are executed. By understanding the structure of workflow files and configuring manual triggers, you can customize the behavior of your workflows to suit your specific needs.

Whether you need to perform a one-time action or execute a workflow under specific circumstances, manual triggering allows you to take full advantage of the power and automation capabilities provided by GitHub Actions.

So why wait? Start utilizing the manual triggering feature in GitHub Actions today and streamline your development processes like never before!






Leave a Reply

Your email address will not be published. Required fields are marked *