Skip to content

Default Presets

Default preset configs for Renovate. Source repository

:enableRenovate

Enable renovate

{
  "enabled": true
}

:disableRenovate

Disable renovate

{
  "enabled": false
}

:ignoreModulesAndTests

Ignore node_modules, bower_components, vendor and various test/tests directories

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

:includeNodeModules

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

{
  "ignorePaths": []
}

:pinVersions

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

{
  "rangeStrategy": "pin"
}

:preserveSemverRanges

Preserve (but continue to upgrade) any existing semver ranges

{
  "rangeStrategy": "replace"
}

:pinAllExceptPeerDependencies

Pin dependency versions for all except peerDependencies

{
  "packageRules": [
    {
      "packagePatterns": [
        "*"
      ],
      "rangeStrategy": "pin"
    },
    {
      "depTypeList": [
        "engines",
        "peerDependencies"
      ],
      "rangeStrategy": "auto"
    }
  ]
}

:pinOnlyDevDependencies

Pin dependency versions for devDependencies and retain semver ranges for others

{
  "packageRules": [
    {
      "packagePatterns": [
        "*"
      ],
      "rangeStrategy": "replace"
    },
    {
      "depTypeList": [
        "devDependencies"
      ],
      "rangeStrategy": "pin"
    },
    {
      "depTypeList": [
        "peerDependencies"
      ],
      "rangeStrategy": "widen"
    }
  ]
}

:autodetectPinVersions

Autodetect whether to pin dependencies or maintain ranges

{
  "rangeStrategy": "auto"
}

:separateMajorReleases

Separate major versions of dependencies into individual branches/PRs

{
  "separateMajorReleases": true
}

:separatePatchReleases

Separate patch and minor releases of dependencies into separate PRs

{
  "separatePatchReleases": true
}

:combinePatchMinorReleases

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

{
  "separatePatchReleases": false
}

:renovatePrefix

Use renovate/ as prefix for all branch names

{
  "branchPrefix": "renovate/"
}

:semanticCommitType(<arg0>)

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

{
  "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)"
  ]
}

:disablePeerDependencies

Do not renovate peerDependencies versions/ranges

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

:disableDevDependencies

Do not renovate devDependencies versions/ranges

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

:disableDigestUpdates

Disable digest and git hash updates

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

:semanticPrefixFixDepsChoreOthers

If semantic commits detected, use semantic commit type fix for dependencies and chore for all others

{
  "packageRules": [
    {
      "packagePatterns": [
        "*"
      ],
      "semanticCommitType": "chore"
    },
    {
      "depTypeList": [
        "dependencies"
      ],
      "semanticCommitType": "fix"
    }
  ]
}

:semanticCommitTypeAll(<arg0>)

If semantic commits detected, use semantic commit type arg0 for all

{
  "packageRules": [
    {
      "packagePatterns": [
        "*"
      ],
      "semanticCommitType": "arg0"
    }
  ]
}

:rebaseStalePrs

Rebase existing PRs any time the base branch has been updated

{
  "rebaseStalePrs": true
}

:unpublishSafe

Set a status check to warn when upgrades < 24 hours old might get unpublished

{
  "unpublishSafe": true
}

:unpublishSafeDisabled

Create branches/PRs for dependency upgrades as soon as they're available

{
  "unpublishSafe": false
}

:prImmediately

Raise PRs immediately (after branch is created)

{
  "prCreation": "immediate"
}

:prNotPending

Wait until branch tests have passed or failed before creating the PR

{
  "prCreation": "not-pending"
}

:prHourlyLimitNone

Removes rate limit for PR creation per hour

{
  "prHourlyLimit": 0
}

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

:prConcurrentLimitNone

Remove limit for concurrent Renovate PRs at any time

{
  "prConcurrentLimit": 0
}

:prConcurrentLimit10

Limit to maximum 10 concurrent Renovate PRs at any time

{
  "prConcurrentLimit": 10
}

:prConcurrentLimit20

Limit to maximum 20 concurrent Renovate PRs at any time

{
  "prConcurrentLimit": 20
}

:disableRateLimiting

Remove hourly and concurrent rate limits

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

:automergeDisabled

Disable automerging feature - wait for humans to merge all PRs

{
  "automerge": false
}

:automergeDigest

Automerge digest upgrades if they pass tests

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

:automergePatch

Automerge patch upgrades if they pass tests

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

:automergeMinor

Automerge patch and minor upgrades if they pass tests

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

:automergeMajor

Automerge all upgrades (inluding major) if they pass tests

{
  "automerge": true
}

:automergeAll

Automerge all upgrades (inluding major) if they pass tests

{
  "automerge": true
}

:automergeBranchMergeCommit

If automerging, perform a merge-commit on branch (no PR)

{
  "automergeType": "branch-merge-commit"
}

:automergeBranchPush

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

{
  "automergeType": "branch-push"
}

:automergePr

Raise a PR first before any automerging

{
  "automergeType": "pr"
}

:automergeRequireAllStatusChecks

Require all status checks to pass before any automerging

{
  "requiredStatusChecks": []
}

:skipStatusChecks

Skip status checks and automerge right away

{
  "requiredStatusChecks": null
}

:maintainLockFilesDisabled

Update existing lock files only when package.json is modified

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

:pinDigestsDisabled

Disable pinning of docker dependency digests

{
  "pinDigests": false
}

:maintainLockFilesWeekly

Run lock file maintenance (updates) early Monday mornings

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

:maintainLockFilesMonthly

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

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

:ignoreUnstable

Upgrade to unstable versions only if the existing version is unstable

{
  "ignoreUnstable": true
}

:respectLatest

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

{
  "respectLatest": true
}

:updateNotScheduled

Keep existing branches updated even when not scheduled

{
  "updateNotScheduled": true
}

:noUnscheduledUpdates

Make no updates to branches when not scheduled

{
  "updateNotScheduled": false
}

:automergeLinters

Update lint packages automatically if tests pass

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

:doNotPinPackage(<arg0>)

Disable version pinning for arg0

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

:pinSkipCi

Add [skip ci] to commit message body whenever pinning

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

:gitSignOff

Append git Signed-off-by signature to git commits.

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

:npm

Keep package.json npm dependencies updated

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

:gomod

Enable Go modules support

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

:onlyNpm

Renovate only npm dependencies

{
  "docker": {
    "enabled": false
  },
  "meteor": {
    "enabled": false
  }
}

:docker

Keep Dockerfile FROM sources updated

{
  "docker": {
    "enabled": true
  }
}

:meteor

Keep Meteor Npm.depends packages updated

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

:group(<arg0>, <arg1>)

Group arg1 packages into same branch/PR

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

:label(<arg0>)

Apply label arg0 to PRs

{
  "labels": [
    "arg0"
  ]
}

:labels(<arg0>, <arg1>)

Apply labels arg0 and arg1 to PRs

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

:assignee(<arg0>)

Assign PRs to arg0

{
  "assignees": [
    "arg0"
  ]
}

:reviewer(<arg0>)

Add arg0 as reviewer for PRs

{
  "reviewers": [
    "arg0"
  ]
}

:assignAndReview(<arg0>)

Set arg0 as assignee and reviewer of PRs

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

:semanticCommits

Use semantic prefixes for commit messages and PR titles

{
  "semanticCommits": true
}

:semanticCommitsDisabled

Disable semantic prefixes for commit messages and PR titles

{
  "semanticCommits": false
}

:disableLockFiles

Disable lock file updates

{
  "updateLockFiles": false
}

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

:widenPeerDependencies

Always widen peerDependencies semver ranges when updating, instead of replacing

{
  "packageRules": [
    {
      "depTypeList": [
        "peerDependencies"
      ],
      "versionStrategy": "widen"
    }
  ]
}

:masterIssue

Enable Renovate master issue creation

{
  "masterIssue": true
}

:masterIssueApproval

Enable Renovate master issue approval workflow

{
  "masterIssueApproval": true
}

:timezone(<arg0>)

Evaluate schedules according to timezone arg0

{
  "timezone": "arg0"
}

:pathSemanticCommitType(<arg0>, <arg1>)

Use semanticCommitType arg0 for all package files matching path arg1

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

:followTag(<arg0>, <arg1>)

For package arg0, strictly follow release tag arg1

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

:base

deprecated alias for config:base

{
  "extends": [
    "config:base"
  ]
}

:app

deprecated alias for config:js-app

{
  "extends": [
    "config:js-app"
  ]
}

:library

deprecated alias for config:js-lib

{
  "extends": [
    "config:js-lib"
  ]
}