Default Presets

:approveMajorUpdates¶

Require Dependency Dashboard approval for major updates.

{
  "packageRules": [
    {
      "dependencyDashboardApproval": true,
      "matchUpdateTypes": [
        "major"
      ]
    }
  ]
}

:assignAndReview(`<arg0>`)¶

Set arg0 as assignee and reviewer of PRs.

{
  "extends": [
    ":assignee(arg0)",
    ":reviewer(arg0)"
  ]
}

:assignee(`<arg0>`)¶

Assign PRs to arg0.

{
  "assignees": [
    "arg0"
  ]
}

:automergeAll¶

Automerge all upgrades (including major) if they pass tests.

{
  "automerge": true
}

:automergeBranch¶

If automerging, push the new commit directly to the base branch (no PR).

{
  "automergeType": "branch"
}

:automergeDigest¶

Automerge digest upgrades if they pass tests.

{
  "digest": {
    "automerge": true
  }
}

:automergeDisabled¶

Disable automerging feature - wait for humans to merge all PRs.

{
  "automerge": false
}

:automergeLinters¶

Update lint packages automatically if tests pass.

{
  "packageRules": [
    {
      "automerge": true,
      "extends": [
        "packages:linters"
      ]
    }
  ]
}

:automergeMajor¶

Automerge all upgrades (including major) if they pass tests.

{
  "automerge": true
}

:automergeMinor¶

Automerge patch and minor upgrades if they pass tests.

{
  "lockFileMaintenance": {
    "automerge": true
  },
  "minor": {
    "automerge": true
  },
  "patch": {
    "automerge": true
  },
  "pin": {
    "automerge": true
  }
}

:automergePatch¶

Automerge patch upgrades if they pass tests.

{
  "lockFileMaintenance": {
    "automerge": true
  },
  "patch": {
    "automerge": true
  },
  "pin": {
    "automerge": true
  },
  "separateMinorPatch": true
}

:automergePr¶

Raise a PR first before any automerging.

{
  "automergeType": "pr"
}

:automergeRequireAllStatusChecks¶

Require all status checks to pass before any automerging.

{
  "ignoreTests": false
}

:automergeStableNonMajor¶

Automerge non-major upgrades for semver stable packages if they pass tests.

{
  "packageRules": [
    {
      "automerge": true,
      "matchCurrentVersion": "!/^0/",
      "matchUpdateTypes": [
        "minor",
        "patch"
      ]
    }
  ]
}

:automergeTesters¶

Update testing packages automatically if tests pass.

{
  "packageRules": [
    {
      "automerge": true,
      "extends": [
        "packages:test"
      ]
    }
  ]
}

:automergeTypes¶

Update @types/* packages automatically if tests pass.

{
  "packageRules": [
    {
      "automerge": true,
      "matchPackageNames": [
        "@types/**"
      ]
    }
  ]
}

:combinePatchMinorReleases¶

Do not separate patch and minor upgrades into separate PRs for the same dependency.

{
  "separateMinorPatch": false
}

:configMigration¶

Enable Renovate configuration migration PRs when needed.

{
  "configMigration": true
}

:dependencyDashboard¶

Enable Renovate Dependency Dashboard creation.

{
  "dependencyDashboard": true
}

:dependencyDashboardApproval¶

Enable Renovate Dependency Dashboard approval workflow.

{
  "dependencyDashboardApproval": true
}

:disableDependencyDashboard¶

Disable Renovate Dependency Dashboard creation.

{
  "dependencyDashboard": false
}

:disableDevDependencies¶

Do not update devDependencies versions/ranges.

{
  "packageRules": [
    {
      "enabled": false,
      "matchDepTypes": [
        "devDependencies"
      ]
    }
  ]
}

:disableDigestUpdates¶

Disable digest and Git hash updates.

{
  "digest": {
    "enabled": false
  }
}

:disableDomain(`<arg0>`)¶

Disable requests to a particular domain.

{
  "hostRules": [
    {
      "enabled": false,
      "matchHost": "arg0"
    }
  ]
}

:disableHost(`<arg0>`)¶

Disable requests to a particular host.

{
  "hostRules": [
    {
      "enabled": false,
      "matchHost": "https://arg0"
    }
  ]
}

:disableLockFiles¶

Disable lock file updates.

{
  "updateLockFiles": false
}

:disableMajorUpdates¶

Disable major updates.

{
  "major": {
    "enabled": false
  }
}

:disablePeerDependencies¶

Do not update peerDependencies versions/ranges.

{
  "packageRules": [
    {
      "enabled": false,
      "matchDepTypes": [
        "peerDependencies"
      ]
    }
  ]
}

:disablePrControls¶

Remove the checkbox controls from PRs.

{
  "prBodyTemplate": "{{{header}}}{{{table}}}{{{notes}}}{{{changelogs}}}{{{configDescription}}}{{{footer}}}"
}

:disableRateLimiting¶

Remove hourly and concurrent rate limits.

{
  "prConcurrentLimit": 0,
  "prHourlyLimit": 0
}

:disableRenovate¶

Disable Renovate.

{
  "enabled": false
}

:disableVulnerabilityAlerts¶

Disable vulnerability alerts completely.

{
  "vulnerabilityAlerts": {
    "enabled": false
  }
}

:docker¶

Keep Dockerfile FROM sources updated.

{
  "docker-compose": {
    "enabled": true
  },
  "dockerfile": {
    "enabled": true
  }
}

:doNotPinPackage(`<arg0>`)¶

Disable version pinning for arg0.

{
  "packageRules": [
    {
      "matchPackageNames": [
        "arg0"
      ],
      "rangeStrategy": "replace"
    }
  ]
}

:enablePreCommit¶

Enable the pre-commit manager.

{
  "pre-commit": {
    "enabled": true
  }
}

:enableRenovate¶

Enable Renovate.

{
  "enabled": true
}

:enableVulnerabilityAlerts¶

Raise PR when vulnerability alerts are detected.

{
  "vulnerabilityAlerts": {
    "enabled": true
  }
}

:enableVulnerabilityAlertsWithLabel(`<arg0>`)¶

Raise PR when vulnerability alerts are detected with label arg0.

{
  "vulnerabilityAlerts": {
    "enabled": true,
    "labels": [
      "arg0"
    ]
  }
}

:followTag(`<arg0>`, `<arg1>`)¶

For package arg0, strictly follow release tag arg1.

{
  "packageRules": [
    {
      "followTag": "arg1",
      "matchPackageNames": [
        "arg0"
      ]
    }
  ]
}

:githubComToken(`<arg0>`)¶

Use provided token for github.com lookups. Do not configure this if you are already running on github.com.

{
  "hostRules": [
    {
      "encrypted": {
        "token": "arg0"
      },
      "matchHost": "github.com"
    }
  ]
}

:gitSignOff¶

Append Signed-off-by: to signoff Git commits.

{
  "commitBody": "Signed-off-by: {{{gitAuthor}}}"
}

:gomod¶

Enable Go modules support.

{
  "gomod": {
    "enabled": true
  }
}

:group(`<arg0>`, `<arg1>`)¶

Group arg1 packages into same branch/PR.

{
  "packageRules": [
    {
      "extends": [
        "arg0"
      ],
      "groupName": "arg1"
    }
  ]
}

:ignoreModulesAndTests¶

Ignore node_modules, bower_components, vendor and various test/tests (except for nuget) directories.

{
  "ignorePaths": [
    "**/node_modules/**",
    "**/bower_components/**",
    "**/vendor/**",
    "**/examples/**",
    "**/__tests__/**",
    "**/test/**",
    "**/tests/**",
    "**/__fixtures__/**"
  ],
  "nuget": {
    "ignorePaths": [
      "**/node_modules/**",
      "**/bower_components/**",
      "**/vendor/**",
      "**/examples/**",
      "**/__fixtures__/**"
    ]
  }
}

:ignoreUnstable¶

Upgrade to unstable versions only if the existing version is unstable.

{
  "ignoreUnstable": true
}

:includeNodeModules¶

Include package.json files found within node_modules folders or bower_components.

{
  "ignorePaths": []
}

:label(`<arg0>`)¶

Apply label arg0 to PRs.

{
  "labels": [
    "arg0"
  ]
}

:labels(`<arg0>`, `<arg1>`)¶

Apply labels arg0 and arg1 to PRs.

{
  "labels": [
    "arg0",
    "arg1"
  ]
}

:maintainLockFilesDisabled¶

Update existing lock files only when package.json is modified.

{
  "lockFileMaintenance": {
    "enabled": false
  }
}

:maintainLockFilesMonthly¶

Run lock file maintenance (updates) on the first day of each month.

{
  "lockFileMaintenance": {
    "enabled": true,
    "extends": [
      "schedule:monthly"
    ]
  }
}

:maintainLockFilesWeekly¶

Run lock file maintenance (updates) early Monday mornings.

{
  "lockFileMaintenance": {
    "enabled": true,
    "extends": [
      "schedule:weekly"
    ]
  }
}

:meteor¶

Keep Meteor Npm.depends packages updated.

{
  "meteor": {
    "enabled": true
  }
}

:noUnscheduledUpdates¶

Only update branches when scheduled.

{
  "updateNotScheduled": false
}

:npm¶

Keep package.json npm dependencies updated.

{
  "npm": {
    "enabled": true
  }
}

:pathSemanticCommitType(`<arg0>`, `<arg1>`)¶

Use semanticCommitType arg1 for all package files matching path arg0.

{
  "packageRules": [
    {
      "matchFileNames": [
        "arg0"
      ],
      "semanticCommitType": "arg1"
    }
  ]
}

:pinAllExceptPeerDependencies¶

Pin all dependency versions except peerDependencies.

{
  "packageRules": [
    {
      "matchPackageNames": [
        "*"
      ],
      "rangeStrategy": "pin"
    },
    {
      "matchDepTypes": [
        "engines",
        "peerDependencies"
      ],
      "rangeStrategy": "auto"
    }
  ]
}

:pinDependencies¶

Pin dependency versions where depType=dependencies. Usually applies only to non-dev dependencies in package.json.

{
  "packageRules": [
    {
      "matchDepTypes": [
        "dependencies"
      ],
      "rangeStrategy": "pin"
    }
  ]
}

:pinDevDependencies¶

Pin dependency versions for devDependencies.

{
  "packageRules": [
    {
      "matchDepTypes": [
        "devDependencies"
      ],
      "rangeStrategy": "pin"
    }
  ]
}

:pinDigestsDisabled¶

Disable pinning of Docker dependency digests.

{
  "pinDigests": false
}

:pinOnlyDevDependencies¶

Pin dependency versions for devDependencies and retain SemVer ranges for others.

{
  "packageRules": [
    {
      "matchPackageNames": [
        "*"
      ],
      "rangeStrategy": "replace"
    },
    {
      "matchDepTypes": [
        "devDependencies"
      ],
      "rangeStrategy": "pin"
    },
    {
      "matchDepTypes": [
        "peerDependencies"
      ],
      "rangeStrategy": "widen"
    }
  ]
}

:pinSkipCi¶

Add [skip ci] to commit message body whenever pinning.

{
  "pin": {
    "commitBody": "[skip ci]"
  }
}

:pinVersions¶

Use version pinning (maintain a single version only and not SemVer ranges).

{
  "rangeStrategy": "pin"
}

:prConcurrentLimit10¶

Limit to maximum 10 open PRs at any time.

{
  "prConcurrentLimit": 10
}

:prConcurrentLimit20¶

Limit to maximum 20 open PRs at any time.

{
  "prConcurrentLimit": 20
}

:prConcurrentLimitNone¶

Remove limit for open PRs at any time.

{
  "prConcurrentLimit": 0
}

:preserveSemverRanges¶

Preserve (but continue to upgrade) any existing SemVer ranges.

{
  "packageRules": [
    {
      "matchPackageNames": [
        "*"
      ],
      "rangeStrategy": "replace"
    }
  ]
}

:prHourlyLimit1¶

Rate limit PR creation to a maximum of one per hour.

{
  "prHourlyLimit": 1
}

:prHourlyLimit2¶

Rate limit PR creation to a maximum of two per hour.

{
  "prHourlyLimit": 2
}

:prHourlyLimit4¶

Rate limit PR creation to a maximum of four per hour.

{
  "prHourlyLimit": 4
}

:prHourlyLimitNone¶

Removes rate limit for PR creation per hour.

{
  "prHourlyLimit": 0
}

:prImmediately¶

Raise PRs immediately (after branch is created).

{
  "prCreation": "immediate"
}

:prNotPending¶

Wait for branch tests to pass or fail before creating the PR.

{
  "prCreation": "not-pending"
}

:rebaseStalePrs¶

Rebase existing PRs any time the base branch has been updated.

{
  "rebaseWhen": "behind-base-branch"
}

:renovatePrefix¶

Add the renovate/ prefix to all branch names.

{
  "branchPrefix": "renovate/"
}

:respectLatest¶

Upgrade versions up to the "latest" tag in the npm registry.

{
  "respectLatest": true
}

:reviewer(`<arg0>`)¶

Add arg0 as reviewer for PRs.

{
  "reviewers": [
    "arg0"
  ]
}

:semanticCommits¶

Use semantic prefixes for commit messages and PR titles.

{
  "semanticCommits": "enabled"
}

:semanticCommitScope(`<arg0>`)¶

Use semantic commit scope arg0 for all commits and PR titles.

{
  "semanticCommitScope": "arg0"
}

:semanticCommitScopeDisabled¶

Disable semantic commit scope for all commits and PR titles.

{
  "semanticCommitScope": null
}

:semanticCommitsDisabled¶

Disable semantic prefixes for commit messages and PR titles.

{
  "semanticCommits": "disabled"
}

:semanticCommitType(`<arg0>`)¶

Use arg0 as semantic commit type for commit messages and PR titles.

{
  "semanticCommitType": "arg0"
}

:semanticCommitTypeAll(`<arg0>`)¶

If Renovate detects semantic commits, it will use semantic commit type arg0 for all commits.

{
  "packageRules": [
    {
      "matchFileNames": [
        "**/*"
      ],
      "semanticCommitType": "arg0"
    }
  ]
}

:semanticPrefixChore¶

Use chore as semantic commit type for commit messages and PR titles.

{
  "extends": [
    ":semanticCommitType(chore)"
  ]
}

:semanticPrefixFix¶

Use fix as semantic commit type for commit messages and PR titles.

{
  "extends": [
    ":semanticCommitType(fix)"
  ]
}

:semanticPrefixFixDepsChoreOthers¶

Use semantic commit type fix for dependencies and chore for all others if semantic commits are in use.

{
  "packageRules": [
    {
      "matchPackageNames": [
        "*"
      ],
      "semanticCommitType": "chore"
    },
    {
      "matchDepTypes": [
        "dependencies",
        "require"
      ],
      "semanticCommitType": "fix"
    },
    {
      "matchDatasources": [
        "maven"
      ],
      "matchDepTypes": [
        "compile",
        "provided",
        "runtime",
        "system",
        "import",
        "parent"
      ],
      "semanticCommitType": "fix"
    },
    {
      "matchDepTypes": [
        "project.dependencies",
        "project.optional-dependencies"
      ],
      "matchManagers": [
        "pep621"
      ],
      "semanticCommitType": "fix"
    },
    {
      "matchDepTypes": [
        "dependencies",
        "extras"
      ],
      "matchManagers": [
        "poetry"
      ],
      "semanticCommitType": "fix"
    }
  ]
}

:separateMajorReleases¶

Separate major versions of dependencies into individual branches/PRs.

{
  "separateMajorMinor": true
}

:separateMultipleMajorReleases¶

Separate each major version of dependencies into individual branches/PRs.

{
  "separateMajorMinor": true,
  "separateMultipleMajor": true
}

:separateMultipleMinorReleases¶

Separate each minor version of dependencies into individual branches/PRs.

{
  "separateMultipleMinor": true
}

:separatePatchReleases¶

Separate patch and minor releases of dependencies into separate PRs.

{
  "separateMinorPatch": true
}

:skipStatusChecks¶

Skip status checks and automerge right away.

{
  "ignoreTests": true
}

:timezone(`<arg0>`)¶

Evaluate schedules according to timezone arg0.

{
  "timezone": "arg0"
}

:updateNotScheduled¶

Keep existing branches updated even when not scheduled.

{
  "updateNotScheduled": true
}

:widenPeerDependencies¶

Always widen peerDependencies SemVer ranges when updating, instead of replacing.

{
  "packageRules": [
    {
      "matchDepTypes": [
        "peerDependencies"
      ],
      "rangeStrategy": "widen"
    }
  ]
}