"reviewdog" provides a way to post review comments to code hosting service, such as GitHub, automatically by integrating with any linter tools with ease. It uses an output of lint tools and posts them as a comment if findings are in diff of patches to review.

reviewdog also supports run in the local environment to filter an output of lint tools by diff.

Automated code review tool integrated with any code analysis tools regardless of programming language.

github-pr-check sample
comment in pull-request
commit status


# Install latest version. (Install it into ./bin/ by default).
$ curl -sfL| sh -s

# Specify installation directory ($(go env GOPATH)/bin/) and version.
$ curl -sfL| sh -s -- -b $(go env GOPATH)/bin [vX.Y.Z]

# In alpine linux (as it does not come with curl by default)
$ wget -O - -q| sh -s [vX.Y.Z]


$ go get -u

homebrew / linuxbrew

You can also install reviewdog using brew:

$ brew install reviewdog/tap/reviewdog
$ brew upgrade reviewdog/tap/reviewdog

Input Format


reviewdog accepts any compiler or linter result from stdin and parses it with
scan-f like 'errorformat',
which is the port of Vim's errorformat

For example, if the result format is {file}:{line number}:{column number}: {message},
errorformat should be %f:%l:%c: %m and you can pass it as -efm arguments.

$ golint ./...
comment_iowriter.go:11:6: exported type CommentWriter should have comment or be unexported
$ golint ./... | reviewdog -efm="%f:%l:%c: %m" -diff="git diff master"
name description
%f file name
%l line number
%c column number
%m error message
%% the single '%' character
... ...

Please see reviewdog/errorformat
and :h errorformat
if you want to deal with a more complex output. 'errorformat' can handle more
complex output like a multi-line error message.

You can also try errorformat on the Playground!

By this 'errorformat' feature, reviewdog can support any tools output with ease.

Available pre-defined 'errorformat'

But, you don't have to write 'errorformat' in many cases. reviewdog supports
pre-defined errorformat for major tools.

You can find available errorformat name by reviewdog -list and you can use it
with -f={name}.

$ reviewdog -list
golint          linter for Go source code                                       -
govet           Vet examines Go source code and reports suspicious problems     -
sbt             the interactive build tool                                      -
$ golint ./... | reviewdog -f=golint -diff="git diff master"

You can add supported pre-defined 'errorformat' by contributing to reviewdog/errorformat

checkstyle format

reviewdog also accepts checkstyle XML format as well.
If the linter supports checkstyle format as a report format, you can use
-f=checkstyle instead of using 'errorformat'.

# Local
$ eslint -f checkstyle . | reviewdog -f=checkstyle -diff="git diff"

# CI (overwrite tool name which is shown in review comment by -name arg)
$ eslint -f checkstyle . | reviewdog -f=checkstyle -name="eslint" -reporter=github-pr-check

Also, if you want to pass other Json/XML/etc... format to reviewdog, you can write a converter.

$ <linter> | <convert-to-checkstyle> | reviewdog -f=checkstyle -name="<linter>" -reporter=github-pr-check

reviewdog config file

reviewdog can also be controlled via the .reviewdog.yml configuration file instead of "-f" or "-efm" arguments.

With .reviewdog.yml, you can run the same commands both CI service and local
environment including editor integration with ease.


    cmd: <command> # (required)
    errorformat: # (optional if there is supporeted format for <tool-name>. see reviewdog -list)
      - <list of errorformat>
    name: <tool-name> # (optional. you can overwrite <tool-name> defined by runner key)
    level: <level> # (optional. same as -level flag. [info,warning,error])

  # examples
    cmd: golint ./...
      - "%f:%l:%c: %m"
    level: warning
    cmd: go tool vet -all -shadowstrict .
$ reviewdog -diff="git diff master"
project/run_test.go:61:28: [golint] error strings should not end with punctuation
project/run.go:57:18: [errcheck]        defer os.Setenv(name, os.Getenv(name))
project/run.go:58:12: [errcheck]        os.Setenv(name, "")
# You can use -runners to run only specified runners.
$ reviewdog -diff="git diff master" -runners=golint,govet
project/run_test.go:61:28: [golint] error strings should not end with punctuation
# You can use -conf to specify config file path.
$ reviewdog -conf=./.reviewdog.yml -reporter=github-pr-check

Output format for project config based run is one of the following formats.

  • <file>: [<tool name>] <message>
  • <file>:<lnum>: [<tool name>] <message>
  • <file>:<lnum>:<col>: [<tool name>] <message>


reviewdog can report results both in local environment and review services as
continuous integration.

Reporter: Local (-reporter=local) [default]

reviewdog can find newly introduced findings by filtering linter results
using diff. You can pass diff command as -diff arg.

$ golint ./... | reviewdog -f=golint -diff="git diff master"

Reporter: GitHub Checks (-reporter=github-pr-check)

github-pr-check sample annotation with option 1
github-pr-check sample

github-pr-check reporter reports results to GitHub Checks.

You can change report level for this reporter by level field in config
or -level flag. You can control GitHub status
check result with this feature. (default: error)

Level GitHub Status
info neutral
warning neutral
error failure

There are two options to use this reporter.

Option 1) Run reviewdog from GitHub Actions w/ secrets.GITHUB_TOKEN (experimental)

Example: .github/workflows/reviewdog.yml

- name: Run reviewdog
  run: |
    golint ./... | reviewdog -f=golint -reporter=github-pr-check

See GitHub Actions section too. You can also use public
reviewdog GitHub Actions.

Note that it reports result to GitHub Actions log consle for Pull
Requests from fork repository because due to GitHub Actions
GITHUB_TOKEN for PullRequest from forked repository doesn't have write access
to Check API.
github-pr-check from forked repo example

Option 2) Install reviewdog GitHub Apps

reviewdog CLI send a request to reviewdog GitHub App server and the server post
results as GitHub Checks, because Check API only supported for GitHub App and
GitHub Actions.

  1. Install reviewdog Apps.
  2. Set REVIEWDOG_TOKEN or run reviewdog CLI in trusted CI providers.
  • Get token from{owner}/{repo-name}.
$ export REVIEWDOG_TOKEN="<token>"
$ reviewdog -reporter=github-pr-check

Note: Token is not required if you run reviewdog in Travis or AppVeyor.


As described above, github-pr-check reporter with Option 2 is depending on
reviewdog GitHub App server.
The server is running with haya14busa's pocket money for now and I may break
things, so I cannot ensure that the server is running 24h and 365 days.

UPDATE: Started getting support by opencollective.
See Supporting reviewdog

github-pr-check reporter is better than github-pr-review reporter in general
because it provides more rich feature and has less scope, but please bear in
mind the above caution and please use it on your own risk.

You can use github-pr-review reporter if you don't want to depend on reviewdog

Reporter: GitHub PullRequest review comment (-reporter=github-pr-review)


github-pr-review reporter reports results to GitHub PullRequest review comments
using GitHub Personal API Access Token.
GitHub Enterprise is supported too.

$ reviewdog -reporter=github-pr-review

For GitHub Enterprise, set API endpoint by environment variable.

$ export GITHUB_API=""
$ export REVIEWDOG_INSECURE_SKIP_VERIFY=true # set this as you need to skip verifying SSL

Reporter: GitLab MergeRequest discussions (-reporter=gitlab-mr-discussion)

gitlab-mr-discussion sample

Required GitLab version: >= v10.8.0

gitlab-mr-discussion reporter reports results to GitLab MergeRequest discussions using
GitLab Personal API Access token.
Get the token with api scope from

$ reviewdog -reporter=gitlab-mr-discussion

For self-hosted GitLab, set API endpoint by environment variable.

$ export GITLAB_API=""
$ export REVIEWDOG_INSECURE_SKIP_VERIFY=true # set this as you need to skip verifying SSL

Reporter: GitLab MergeRequest commit (-reporter=gitlab-mr-commit)

gitlab-mr-commit is similar to gitlab-mr-discussion reporter but reports results to each commit in GitLab MergeRequest.

gitlab-mr-discussion is recommended, but you can use gitlab-mr-commit reporter
if your GitLab version is under v10.8.0.

$ reviewdog -reporter=gitlab-mr-commit

Supported CI services

GitHub Actions

Example: .github/workflows/reviewdog.yml

name: reviewdog
on: [pull_request]
    name: reviewdog
    runs-on: ubuntu-latest
      # ...
      - name: Setup reviewdog
        run: |
          mkdir -p $HOME/bin && curl -sfL| sh -s -- -b $HOME/bin
          echo ::add-path::$HOME/bin
          echo ::add-path::$(go env GOPATH)/bin # for Go projects
      - name: Run reviewdog
        run: |
          reviewdog -reporter=github-pr-check -runners=golint,govet

Pubilc Reviewdog GitHub Actions

You can also use public GitHub Actions to start using reviewdog with ease! :tada: :arrow_forward: :tada:

Please open a Pull Request to add your created reviedog actions here :sparkles:.
I can also consider to put your created repositories under reviewdog org and co-maintain the actions.


Travis CI

Travis CI (-reporter=github-pr-check)

If you use -reporter=github-pr-check in Travis CI, you don't need to set REVIEWDOG_TOKEN.


  - mkdir -p ~/bin/ && export export PATH="~/bin/:$PATH"
  - curl -sfL| sh -s -- -b ~/bin

  - reviewdog -conf=.reviewdog.yml -reporter=github-pr-check

Travis CI (-reporter=github-pr-review)

Store GitHub API token by travis encryption keys.

$ gem install travis
$ travis encrypt REVIEWDOG_GITHUB_API_TOKEN=<token> --add


    - secure: <token>

  - mkdir -p ~/bin/ && export export PATH="~/bin/:$PATH"
  - curl -sfL| sh -s -- -b ~/bin

  - >-
    golint ./... | reviewdog -f=golint -reporter=github-pr-review


Circle CI

Environment variables - CircleCI

.circleci/config.yml sample

version: 2
      - image: golang:latest
      - checkout
      - run: curl -sfL| sh -s -- -b ./bin
      - run: go vet ./... 2>&1 | ./bin/reviewdog -f=govet -reporter=github-pr-check
      # or
      - run: go vet ./... 2>&1 | ./bin/reviewdog -f=govet -reporter=github-pr-review

GitLab CI


.gitlab-ci.yml sample

    - reviewdog -reporter=gitlab-mr-discussion
    # Or
    - reviewdog -reporter=gitlab-mr-commit

Common (Jenkins, local, etc...)

You can use reviewdog to post review comments from anywhere with following
environment variables.

name description
CI_PULL_REQUEST Pull Request number (e.g. 14)
CI_COMMIT SHA1 for the current build
CI_REPO_OWNER repository owner (e.g. "haya14busa" for
CI_REPO_NAME repository name (e.g. "reviewdog" for
CI_BRANCH [optional] branch of the commit
$ export CI_PULL_REQUEST=14
$ export CI_REPO_OWNER=haya14busa
$ export CI_REPO_NAME=reviewdog
$ export CI_COMMIT=$(git rev-parse HEAD)

and set a token if required.


If a CI service doesn't provide information such as Pull Request ID - reviewdog can guess it by branch name and commit SHA.
Just pass the flag guess:

$ reviewdog -conf=.reviewdog.yml -reporter=github-pr-check -guess

Jenkins with Github pull request builder plugin

$ export CI_PULL_REQUEST=${ghprbPullId}
$ export CI_REPO_OWNER=haya14busa
$ export CI_REPO_NAME=reviewdog
$ export CI_COMMIT=${ghprbActualCommit}
$ export REVIEWDOG_INSECURE_SKIP_VERIFY=true # set this as you need
$ REVIEWDOG_TOKEN="<token>" reviewdog -reporter=github-pr-check
# Or
$ REVIEWDOG_GITHUB_API_TOKEN="<token>" reviewdog -reporter=github-pr-review