Chainlink core node: the Postgres, execution client and TLS setup it needs

A bundled binary for node operators, not a library you import

What sits in this repository is a program, not a dependency. It contains the Chainlink core node and the contracts, and the core node is the bundled binary that node operators run to take part in a decentralized oracle network. The stated purpose of the project is to expand what smart contracts can do by giving them access to real-world data and off-chain computation while keeping the guarantees that come from the chain itself. The practical consequence is that you do not call Chainlink from your application code. You start a node, point it at a chain, and it participates in the network as its own process. Which chain it talks to is not guessed: any Ethereum based network works only after you have configured the chain ID, so a node you start without that step has no network to attach to.

The build asks for Go 1.26.5 while go.mod declares 1.27.1

Build step one tells you to install Go 1.27.3 and put your GOPATH bin directory on your PATH, with a macOS example of exporting PATH and GOPATH. The module declaration at the root of the repository asks for the same version, go 1.27.3. Node tooling is similarly doubled: the steps ask for NodeJS v20 with pnpm v10 installed through npm, and the root manifest records engines of node >= 18 and pnpm >= 10, pinned to pnpm 10.11.1. Postgres is a hard dependency at 15.x or newer, with the caveat that the official docker image caps out at 18.x because of the bundled client, and it should be configured for an SSL connection unless you append ?sslmode=disable to the query string while testing.

git clone https://github.com/smartcontractkit/chainlink && cd chainlink

make install

chainlink help

TLS is on by default, so a local node needs a dev build

Out of the box the node serves its interface over TLS, which is the right default for an operator but an obstacle when you are pointing a browser at your own machine. Two routes around it are offered. The first is a dev build made with make chainlink-dev plus three TOML fields that turn off secure cookies, move the HTTPS port to 0 and enable the developer web server. The second is to keep TLS and generate self signed certificates with tools/bin/self-signed-certs, or by hand. Once either is in place you start the node with a single command, and it listens on port 6688 by default, with the UI served from there.

Nethermind and Erigon are supported but listed as broken

The execution client matrix is the most opinionated part of the documentation, and it is split into two tiers. Officially supported are Parity and OpenEthereum, Geth and Besu, with a warning attached to Parity that it is deprecated and support for it may be removed in future. Below that sits a supported but broken tier, described as clients Chainlink supports but whose bugs prevent it working reliably: Nethermind, whose blocking issue is struck through in the list, and Erigon, with two open blocking issues referenced. You must supply a running Ethereum node with an open websocket connection, so this choice is yours to make and it determines whether the node is dependable. Version pinning is explicitly refused, since the clients keep moving and the guidance is to run the latest release available.

Plugins are yaml files with a plugins. prefix, installed by loopinstall

Extensibility runs through a directory of yaml files rather than through a registry. Plugins are defined in the plugins/ directory, every plugin file carries a plugins. prefix in its name, and installation is handled by a tool called loopinstall that lives in chainlink-common under pkg/loop/cmd/loopinstall. The public set installs with a single make target. The private set does not, because plugins referenced from plugins/plugins.private.yaml point at private GitHub repositories, so you need a GITHUB_TOKEN environment variable or the GitHub CLI credential helper, after which a separate private target builds them. A third path builds the experimental plugins docker image, and it also wants the token exported first.

make install-plugins

# Sets up a credential helper.
gh auth setup-git

make install-plugins-private

# The GITHUB_TOKEN is required to access private repos which are used by some plugins.
export GITHUB_TOKEN=$(gh auth token) # requires the `gh` cli tool.
make docker-plugins

The go.mod dependency list tells you what the node actually talks to

Reading the module requirements is the fastest way to understand the node's shape, and the list is long and specific. Configuration arrives through BurntSushi/toml, which is the TOML file you edit for ports and dev settings. The web interface is a Gin server, with helmet, cors, sessions, expvar and size middleware in the same group, and gorilla/websocket sits alongside it for chain connections. Chain access is not Ethereum only: go-ethereum, solana-go and an Aptos SDK are all required, which is a fair warning that supporting more chains is a standing cost. Scheduling runs on gocron, and the operational surface includes sentry-go, an LDAP client, WebAuthn, JWT handling, pprof and OpenTelemetry profiling. The directory layout matches: core/, internal/, common/, ccip/, deployment/, operator_ui/, plugins/ and tools/ at the top, plus separate integration, system and fuzz test trees.

Release images are official, images built from a PR are not

Two image stories sit side by side, and the difference matters if you are testing a change. Pre-built docker images exist for all major release versions and are published on the Chainlink dockerhub, which is what you want for anything resembling production. Images built from a feature branch or a pull request are explicitly described as unofficial and testing only. There are two ways to get one: dispatch the docker-build workflow by hand, or add the build-publish label to the pull request and then either retry that workflow or push a new commit to trigger it. Note that the pull request label path does not build anything on its own, it queues a run, so a green image appears only after the workflow actually executes. For setup detail beyond the README, the Development Setup Guide in the project wiki is the linked next step, with docs.chain.link as the wider reference.

Editorial conclusion

It suits node operators joining a decentralized oracle network, integrators wiring feeds into their own contracts, and contributors who need the node to exercise changes locally. It does not suit anyone expecting a JavaScript package to drop in, and it is a poor fit on Nethermind or Erigon, which the project lists as supported but broken. Before you commit a machine to it, confirm four things: your execution client is Geth, Besu or still-viable Parity, your Postgres is 15 or newer and no newer than 18.x if you use the official image, whether any of your plugins come from plugins.private.yaml and therefore need a GITHUB_TOKEN, and that you have Go 1.27.3, the version both the build steps and go.mod name. Expect to read docs.chain.link and the wiki for anything the README leaves out.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. Releases
5. smartcontractkit/chainlink on GitHub