Skip to content

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": ">= 1.0.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"
    }
  ]
}

: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"
    }
  ]
}