GitHub Integration

Connect QuantAssure to your GitHub organization to monitor repository security.

What It Collects

  • Repository Inventory — All repositories in your organization as assets
  • Dependabot Alerts — Vulnerability alerts from GitHub's Dependabot (the Dependabot Alerts extension, on by default)
  • Code Scanning Alerts — Vulnerability findings from GitHub code scanning (CodeQL and other SARIF-based scanners), for alerts that carry a security severity (the Code Scanning Alerts extension, off by default)
  • Security Settings — Branch protection, secret scanning, and other security configurations (the GitHub Security Compliance extension, on by default for plans that include it)

Choose how to connect

Each GitHub system has one GitHub access setting on its create and edit forms:

  • GitHub App (recommended) — Install the QuantAssure GitHub App on your organization. No personal access token is created or stored: each scan uses a short-lived token issued by GitHub for the installation, so access does not depend on one person's account. The organization scanned is the one the App is installed on. Only shown when your deployment has the App available.
  • Personal access token — Paste a token that you create in GitHub. Choose this if the App is not available to you, or if you want a token that an administrator manages themselves.

Systems created before the App option existed keep using their token and show Personal access token.

Set up with the GitHub App

You need to be able to install apps on your GitHub organization (an organization owner, or someone an owner has approved).

  1. Go to Inventory → Systems and click Add system
  2. In the Data Source section, turn on GitHub. GitHub access is set to GitHub App (recommended)
  3. Under Extensions, check that Dependabot Alerts is on to collect vulnerability findings. The token fields are not shown for this method, and code scanning uses the same access
  4. Click Create and connect. QuantAssure creates the system and sends you to GitHub
  5. Choose the organization and repositories to install the App on, and approve the authorization prompt
  6. GitHub returns you to the system page with a confirmation. The organization is filled in from the installation and cannot be edited

You must be signed in to GitHub as someone who can see the installation. An installation can be connected to one QuantAssure organization only; if it is already connected elsewhere, the system page tells you so.

Connecting later, changing, or disconnecting

  • If you skipped the install, open the system and click Edit. The GitHub card shows Connect GitHub App. The system page also shows Set up GitHub access under Real-time Sources, which opens the same screen.
  • To re-link (for example after reinstalling the App), use Disconnect on the edit screen, then connect again. Disconnect only unlinks the system. The App stays installed on GitHub; to remove it, uninstall it in your GitHub organisation settings.
  • To switch an existing system to the App, change GitHub access to GitHub App, save, then connect. The personal access tokens saved on the system are removed when you save, so switching back means entering a token again.
  • If a system on the App is not connected (never connected, or disconnected), its runs fail with a message saying so and pointing to the edit screen. If GitHub will not issue an access token (the App was uninstalled or suspended), runs fail the same way until you reconnect it.
  • Once connected, repository and security events also arrive without waiting for the next scheduled run.

What the App needs

The App only reads. Your administrator grants these when the App is published; if a permission is missing, the run still completes and the affected findings are missing (the run notes what could not be checked).

  • Repository: Metadata, Contents, Pull requests, Dependabot alerts, Code scanning alerts, Secret scanning alerts, Administration (to read branch protection and secret scanning status), Checks and Commit statuses, all read-only
  • Organization: Members and Administration, both read-only (members and whether they use two-factor authentication)

Set up with a personal access token

Prerequisites

  • A GitHub account with access to your organization
  • A Personal Access Token (PAT) with the following scopes:
    • repo — Full control of private repositories (for Dependabot alerts)
    • read:org — Read organization membership
    • security_events — Read code scanning alerts (only needed if you enable Code Scanning Alerts)
  • Using a fine-grained token instead? Give it read access to the repositories you want checked, plus Pull requests: Read, Checks: Read and Commit statuses: Read. QuantAssure uses these to show whether Dependabot's fix pull request is open, passing CI, merged or closed. If the token lacks them, the pull request state may be missing or show as unknown

1. Generate a Personal Access Token

  1. Go to GitHub → Settings → Developer settings → Personal access tokens → Tokens (classic)
  2. Click "Generate new token" → "Generate new token (classic)"
  3. Give it a descriptive name (e.g., "QuantAssure")
  4. Select scopes: repo and read:org. Also select security_events if you plan to enable Code Scanning Alerts
  5. Click "Generate token"
  6. Copy the token immediately — you won't see it again

2. Configure in QuantAssure

  1. Go to Inventory → Systems and click Add system, or open a system and click Edit
  2. In the Data Source section, turn on GitHub and set GitHub access to Personal access token
  3. Enter your GitHub organization name in Organisation
  4. Paste your token into Personal Access Token
  5. Under Extensions, check that Dependabot Alerts is on to collect vulnerability findings
  6. (Optional) Turn on Code Scanning Alerts to collect findings from CodeQL and other code scanning tools. It uses the same token. A different token with the security_events permission can be entered in its own Personal Access Token field
  7. Click Create system, or save your changes if you are editing

Optional: live updates with the GitHub App

A system on the token method can also have the App connected for live events. The system page does not offer this for token systems: install the App from GitHub, then link it to the system on the page GitHub sends you to.

Run Your First Collection

On the system page, click Run Now to collect data from GitHub. The run will:

  • Fetch all repositories in your organization
  • Collect Dependabot alerts for each repository (if enabled)
  • Collect code scanning alerts for each repository (if enabled)
  • Check security settings on each repository (if GitHub Security Compliance is on)

Fixing findings from QuantAssure

Some findings include a recommended fix, such as turning on branch protection, secret scanning or Dependabot for a repository. Where the finding describes the change and links to the GitHub settings page where you can make it. QuantAssure gives guidance and does not change your repositories.

What to Expect

After your first run:

  • Assets: One asset per repository in your organization
  • Findings: Dependabot vulnerability alerts (if enabled)
  • Findings include CVE details, severity, and affected package information
  • Findings: Code scanning alerts (if enabled) — only alerts that carry a security severity are turned into findings; lint-grade CodeQL results and other non-security SARIF results are deliberately excluded
  • Dependabot findings also show the state of Dependabot's fix pull request (the Dependabot Fix PRs extension, on by default): no PR, open and waiting for merge, open with failing CI, a major version bump, merged, or closed without merging. See Findings
  • Code scanning findings are shown with QuantAssure's AI-adjusted severity, which reflects your organisational context; the scanner's original severity is retained for the audit trail
  • If you dismiss an alert in GitHub, it isn't removed from QuantAssure — it's shown as a risk acceptance, with who dismissed it, when, and the reason given
  • Repositories without code scanning enabled are skipped silently — this is expected and doesn't indicate a problem
  • If QuantAssure is temporarily unable to check code scanning for a repository, that repository's existing findings are left unchanged rather than marked resolved — a failed check is never treated as "nothing to report"

Troubleshooting

"Bad credentials" error

  • On the App method there is no token to check: open the system and make sure the GitHub App is still connected, and that it is still installed on your organization in GitHub
  • On the token method, verify your Personal Access Token is correct
  • Check that the token hasn't expired
  • Ensure the token has repo and read:org scopes

No Dependabot alerts appearing

  • Verify Dependabot is enabled on your repositories
  • Check that the Dependabot Alerts extension is enabled in QuantAssure
  • Some repositories may not have any alerts

No code scanning alerts appearing

  • Verify code scanning (e.g., CodeQL) is enabled on your repositories
  • Check that the Code Scanning Alerts extension is enabled in QuantAssure
  • Remember that alerts without a security severity — lint-grade CodeQL results, most third-party SARIF uploads — are excluded by design and won't appear as findings
  • If you rely on the GitHub App for near-immediate updates (see connecting a system) rather than waiting for the next scheduled run (daily by default; see scheduled runs), code scanning updates only arrive if that App has been granted the security_events: read permission and is subscribed to the code_scanning_alert webhook event in its GitHub App settings. This is the first thing to check if findings from your scheduled run look right but live updates never show up — contact support to confirm the App's configuration

Missing repositories

  • Verify your organization name is correct
  • Check that your token has access to the organization
  • Private repositories require the repo scope