Skip to main content
Integrate QA.tech into your CI/CD workflows with the GitHub Action. You control which tests run, when they run, and which environments to test.
Looking for automatic AI-powered PR reviews? See GitHub App instead.
1

Configure Secrets

Add the following secrets to your GitHub repository:
  • QATECH_API_TOKEN - Your QA.tech API token
  • QATECH_PROJECT_ID - Your QA.tech project ID
You can find these values in your project settings.Learn more about creating secrets in GitHub Actions.
2

Create Workflow File

Create .github/workflows/qatech.yml in your repository:
name: QA.tech Tests
on:
  push:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: QAdottech/run-action@v2
        with:
          project_id: ${{ secrets.QATECH_PROJECT_ID }}
          api_token: ${{ secrets.QATECH_API_TOKEN }}
          blocking: true
This runs all tests in your project whenever code is pushed to main. The blocking option waits for test results before completing the workflow.
3

Trigger Your First Run

Push to your main branch or open a PR (depending on your workflow configuration). QA.tech will execute your tests and report results directly in the GitHub Actions UI.

​
Basic Usage

The simplest way to run tests is without any additional configuration: 
- uses: QAdottech/run-action@v2
  with:
    project_id: ${{ secrets.QATECH_PROJECT_ID }}
    api_token: ${{ secrets.QATECH_API_TOKEN }}
    blocking: true  # Wait for results before continuing
This executes all tests in your project. For more control, see the examples below.

​
Testing Pull Requests

Run tests automatically when PRs are opened or updated: 
name: QA.tech PR Tests
on:
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: QAdottech/run-action@v2
        with:
          project_id: ${{ secrets.QATECH_PROJECT_ID }}
          api_token: ${{ secrets.QATECH_API_TOKEN }}
          test_plan_short_id: 'smoke-tests'  # Optional: run specific plan
          blocking: true
When to use:
  • Catch issues before merge
  • Validate changes against existing tests
  • Gate PRs based on test results

​
Testing Preview Deployments

Test preview environments with dynamic URLs: 
name: Test Preview Deployment
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  deploy:
    runs-on: ubuntu-latest
    outputs:
      preview_url: ${{ steps.deploy.outputs.url }}
    steps:
      - name: Deploy to Vercel
        id: deploy
        run: |
          # Your deployment logic
          echo "url=https://preview-${{ github.event.number }}.vercel.app" >> $GITHUB_OUTPUT

  test:
    needs: deploy
    runs-on: ubuntu-latest
    steps:
      - uses: QAdottech/run-action@v2
        with:
          project_id: ${{ secrets.QATECH_PROJECT_ID }}
          api_token: ${{ secrets.QATECH_API_TOKEN }}
          test_plan_short_id: 'regression-suite'
          blocking: true
          applications_config: |
            {
              "applications": {
                "frontend-app-id": {
                  "environment": {
                    "url": "${{ needs.deploy.outputs.preview_url }}",
                    "name": "PR-${{ github.event.number }}"
                  }
                }
              }
            }
When to use:
  • Testing Vercel/Netlify preview deployments
  • Multi-environment testing (frontend + backend)
  • PR-specific URL testing

​
Scheduled Testing

Run tests on a schedule (e.g., nightly regression suite): 
name: Nightly Tests
on:
  schedule:
    - cron: '0 2 * * *'  # Daily at 2 AM UTC

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: QAdottech/run-action@v2
        with:
          project_id: ${{ secrets.QATECH_PROJECT_ID }}
          api_token: ${{ secrets.QATECH_API_TOKEN }}
          test_plan_short_id: 'full-regression'
          blocking: false  # Don't block on schedule
When to use:
  • Comprehensive nightly regression testing
  • Production smoke tests
  • Load testing during off-peak hours

​
Direct API Integration

If you prefer direct API calls instead of the GitHub Action, you can use the REST API.

​
Basic Request

curl -X POST \
  -H "Authorization: Bearer $QATECH_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"testPlanShortId": "your-test-plan-id"}' \
  https://app.qa.tech/api/projects/$QATECH_PROJECT_ID/runs

​
With Environment Overrides

curl -X POST \
  -H "Authorization: Bearer $QATECH_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "testPlanShortId": "your-test-plan-id",
    "applications": {
      "app-short-id": {
        "environment": {
          "url": "https://preview.example.com",
          "name": "Preview Environment"
        }
      }
    }
  }' \
  https://app.qa.tech/api/projects/$QATECH_PROJECT_ID/runs
Response format: 
{
  "success": true,
  "run": {
    "id": "run_abc123",
    "shortId": "abc123",
    "url": "https://app.qa.tech/projects/project-123/results/abc123",
    "testCount": 5
  }
}
See the Start Run API Reference for complete documentation including error responses and authentication details.

​
Exploratory Testing with @qatech

Private Beta - This feature is currently in private beta. Request access by emailing daniel@qa.tech
Trigger deep exploratory testing on any pull request by mentioning @qatech in a PR comment. The AI agent analyzes your changes, discovers functionality gaps, creates tests, and provides detailed feedback.
This is different from automatic PR reviews. Exploratory testing is on-demand and focuses on discovering issues through interactive testing, while automatic reviews run on every PR.
How it works: Mention @qatech anywhere in a PR comment: 
@qatech please test the new payment flow
The agent will:
  1. Analyze changes - Examines PR diff and crawls the preview deployment
  2. Check coverage - Identifies which existing tests apply
  3. Create tests - Generates new tests for untested functionality
  4. Run tests - Executes relevant tests against the PR preview
  5. Post review - Writes a detailed GitHub review with findings
When to use exploratory testing vs automatic reviews:
Use Exploratory TestingUse Automatic PR Reviews
Deep investigation of complex changesEvery PR as standard gating
Interactive testing with custom instructionsHands-off automated coverage
Specific areas need thorough validationGeneral functional regression
Debugging test failuresConsistent baseline testing
Example use cases:
  • “Test the entire checkout flow with different payment methods”
  • “Explore what happens when users upload large files”
  • “Check if the new search handles edge cases”
Request private beta access: Email daniel@qa.tech with:
  • Organization name
  • GitHub repository
  • Use case (what you want to test)
You’ll receive setup instructions and access within 1-2 business days.

​
Configuration Reference

GitHub Action Parameter Reference

​
Inputs

InputDescriptionRequiredDefault
project_idYour QA.tech project IDYes-
api_tokenQA.tech API tokenYes-
test_plan_short_idTest plan short ID to runNoAll tests
blockingWait for test results before completingNofalse
applications_configJSON with application environment overridesNo-
api_urlCustom API URLNohttps://app.qa.tech

​
Outputs

OutputDescription
runIdThe ID of the created test run
runShortIdShort ID for the test run
successBoolean indicating if run was successful
run_resultTest execution result (PASSED, FAILED, SKIPPED) - only when blocking: true
run_statusFinal run status (COMPLETED, ERROR, etc.) - only when blocking: true