diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6518c2a77..4dfc3bed1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -78,9 +78,6 @@ jobs:
       - name: Install yarn dependencies
         run: git config --global url."https://".insteadOf ssh:// && yarn install
         if: steps.cache_node.outputs.cache-hit != 'true'
-      - name: Run yarn postinstall if cache hitted
-        run: yarn run postinstall
-        if: steps.cache_node.outputs.cache-hit == 'true'
       - name: Build packages
         run: yarn build
       - name: Check licenses
diff --git a/docs/command-line-interface/config.md b/docs/command-line-interface/config.md
index d074a79f9..9ea26cce8 100644
--- a/docs/command-line-interface/config.md
+++ b/docs/command-line-interface/config.md
@@ -41,6 +41,7 @@ Configure running node information for propagating transactions to network
 ```
 USAGE
   $ celocli config:set [-n <value>] [--globalHelp] [--derivationPath <value>]
+    [--telemetry 1|0]
 
 FLAGS
   -n, --node=<value>            URL of the node to run commands against or an alias
@@ -48,6 +49,8 @@ FLAGS
                                 when using --useLedger flag. Options: 'eth',
                                 'celoLegacy', or a custom derivation path
       --globalHelp              View all available global flags
+      --telemetry=<option>      Whether to enable or disable telemetry
+                                <options: 1|0>
 
 DESCRIPTION
   Configure running node information for propagating transactions to network
@@ -75,6 +78,10 @@ EXAMPLES
 
   set --derivationPath celoLegacy
 
+  set --telemetry 0 # disable telemetry
+
+  set --telemetry 1 # enable telemetry
+
 FLAG DESCRIPTIONS
   -n, --node=<value>  URL of the node to run commands against or an alias
 
diff --git a/package.json b/package.json
index 7ee0e7d88..33e2c91ec 100644
--- a/package.json
+++ b/package.json
@@ -24,7 +24,7 @@
     "check-licenses": "yarn licenses list --prod | grep '\\(─ GPL\\|─ (GPL-[1-9]\\.[0-9]\\+ OR GPL-[1-9]\\.[0-9]\\+)\\)' && echo 'Found GPL license(s). Use 'yarn licenses list --prod' to look up the offending package' || echo 'No GPL licenses found'",
     "report-coverage": "yarn workspaces foreach -piv --all run test-coverage",
     "test:watch": "node node_modules/jest/bin/jest.js --watch",
-    "postinstall": "husky install && yarn workspaces foreach -piv --all run postinstall",
+    "postinstall": "husky install",
     "release": "yarn clean && yarn build && yarn workspace @celo/celocli run prepack && yarn cs publish",
     "version-and-reinstall": "yarn changeset version && yarn install --no-immutable",
     "celocli": "yarn workspace @celo/celocli run --silent celocli"
diff --git a/packages/cli/src/base-l2.test.ts b/packages/cli/src/base-l2.test.ts
index aec3a975b..32e68c2aa 100644
--- a/packages/cli/src/base-l2.test.ts
+++ b/packages/cli/src/base-l2.test.ts
@@ -2,12 +2,14 @@ import { Connection } from '@celo/connect'
 import { testWithAnvilL2 } from '@celo/dev-utils/lib/anvil-test'
 import * as WalletLedgerExports from '@celo/wallet-ledger'
 import { Config, ux } from '@oclif/core'
+import http from 'http'
 import { tmpdir } from 'os'
 import Web3 from 'web3'
 import { BaseCommand } from './base'
 import Set from './commands/config/set'
 import CustomHelp from './help'
 import { stripAnsiCodesFromNestedArray, testLocallyWithWeb3Node } from './test-utils/cliUtils'
+import * as config from './utils/config'
 import { readConfig } from './utils/config'
 
 process.env.NO_SYNCCHECK = 'true'
@@ -67,8 +69,14 @@ describe('flags', () => {
   })
 })
 
+// Make sure telemetry tests are deterministic, otherwise we'd have to update tests every release
+jest.mock('../package.json', () => ({
+  version: '5.2.3',
+}))
+
 testWithAnvilL2('BaseCommand', (web3: Web3) => {
   const logSpy = jest.spyOn(console, 'log').mockImplementation()
+
   beforeEach(() => {
     logSpy.mockClear()
   })
@@ -281,4 +289,183 @@ testWithAnvilL2('BaseCommand', (web3: Web3) => {
       ]
     `)
   })
+
+  describe('telemetry', () => {
+    afterEach(() => {
+      jest.clearAllMocks()
+      jest.restoreAllMocks()
+    })
+
+    it('sends telemetry data successfuly on success', async () => {
+      class TestTelemetryCommand extends BaseCommand {
+        id = 'test:telemetry-success'
+
+        async run() {
+          console.log('Successful run')
+        }
+      }
+
+      // here we test also that it works without this env var
+      delete process.env.TELEMETRY_ENABLED
+      process.env.TELEMETRY_URL = 'https://telemetry.example.org'
+
+      jest.spyOn(config, 'readConfig').mockImplementation((_: string) => {
+        return { telemetry: true } as config.CeloConfig
+      })
+
+      const fetchMock = jest.fn().mockResolvedValue({
+        ok: true,
+      })
+      const fetchSpy = jest.spyOn(global, 'fetch').mockImplementation(fetchMock)
+
+      await TestTelemetryCommand.run([])
+
+      // Assert it was called at all in the first place
+      expect(fetchSpy.mock.calls.length).toEqual(1)
+
+      expect(fetchSpy.mock.calls[0][0]).toMatchInlineSnapshot(`"https://telemetry.example.org"`)
+      expect(fetchSpy.mock.calls[0][1]?.body).toMatchInlineSnapshot(`
+        "
+        celocli_invocation{success="true", version="5.2.3", command="test:telemetry-success"} 1
+        "
+      `)
+      expect(fetchSpy.mock.calls[0][1]?.headers).toMatchInlineSnapshot(`
+        {
+          "Content-Type": "application/octet-stream",
+        }
+      `)
+      expect(fetchSpy.mock.calls[0][1]?.method).toMatchInlineSnapshot(`"POST"`)
+      expect(fetchSpy.mock.calls[0][1]?.signal).toBeInstanceOf(AbortSignal)
+      // Make sure the request was not aborted
+      expect(fetchSpy.mock.calls[0][1]?.signal?.aborted).toBe(false)
+    })
+
+    it('sends telemetry data successfuly on error', async () => {
+      class TestTelemetryCommand extends BaseCommand {
+        id = 'test:telemetry-error'
+
+        async run() {
+          throw new Error('test error')
+        }
+      }
+
+      jest.spyOn(config, 'readConfig').mockImplementation((_: string) => {
+        return { telemetry: true } as config.CeloConfig
+      })
+
+      // here we test also that it works with this env var set to 1 explicitly
+      process.env.TELEMETRY_ENABLED = '1'
+      process.env.TELEMETRY_URL = 'https://telemetry.example.org'
+
+      const fetchMock = jest.fn().mockResolvedValue({
+        ok: true,
+      })
+      const fetchSpy = jest.spyOn(global, 'fetch').mockImplementation(fetchMock)
+
+      await expect(TestTelemetryCommand.run([])).rejects.toMatchInlineSnapshot(
+        `[Error: test error]`
+      )
+
+      // Assert it was called at all in the first place
+      expect(fetchSpy.mock.calls.length).toEqual(1)
+
+      expect(fetchSpy.mock.calls[0][0]).toMatchInlineSnapshot(`"https://telemetry.example.org"`)
+      expect(fetchSpy.mock.calls[0][1]?.body).toMatchInlineSnapshot(`
+        "
+        celocli_invocation{success="false", version="5.2.3", command="test:telemetry-error"} 1
+        "
+      `)
+      expect(fetchSpy.mock.calls[0][1]?.headers).toMatchInlineSnapshot(`
+        {
+          "Content-Type": "application/octet-stream",
+        }
+      `)
+      expect(fetchSpy.mock.calls[0][1]?.method).toMatchInlineSnapshot(`"POST"`)
+      expect(fetchSpy.mock.calls[0][1]?.signal).toBeInstanceOf(AbortSignal)
+      // Make sure the request was not aborted
+      expect(fetchSpy.mock.calls[0][1]?.signal?.aborted).toBe(false)
+    })
+
+    it('does not send telemetry when disabled by config', async () => {
+      class TestTelemetryCommand extends BaseCommand {
+        id = 'test:telemetry-should-not-be-sent'
+
+        async run() {
+          console.log('Successful run')
+        }
+      }
+
+      jest.spyOn(config, 'readConfig').mockImplementation((_: string) => {
+        return { telemetry: false } as config.CeloConfig
+      })
+
+      // we leave it here to double check that it is not sent even if the env var is set
+      process.env.TELEMETRY_ENABLED = '1'
+      process.env.TELEMETRY_URL = 'https://telemetry.example.org'
+
+      const fetchMock = jest.fn().mockResolvedValue({
+        ok: true,
+      })
+      const fetchSpy = jest.spyOn(global, 'fetch').mockImplementation(fetchMock)
+
+      await TestTelemetryCommand.run([])
+
+      expect(fetchSpy).not.toHaveBeenCalled()
+    })
+
+    it('times out after TIMEOUT', async () => {
+      return new Promise<void>((resolve, _) => {
+        const EXPECTED_COMMAND_RESULT = 'Successful run'
+
+        class TestTelemetryCommand extends BaseCommand {
+          id = 'test:telemetry-timeout'
+
+          async run() {
+            return EXPECTED_COMMAND_RESULT
+          }
+        }
+
+        jest.spyOn(config, 'readConfig').mockImplementation((_: string) => {
+          return { telemetry: true } as config.CeloConfig
+        })
+
+        delete process.env.TELEMETRY_ENABLED
+        process.env.TELEMETRY_URL = 'http://localhost:3000/'
+
+        const fetchSpy = jest.spyOn(global, 'fetch')
+
+        const server = http.createServer((_, res) => {
+          setTimeout(() => {
+            res.end()
+          }, 5000) // Higher timeout than the telemetry logic uses
+        })
+
+        server.listen(3000, async () => {
+          // Make sure the command actually returns
+          await expect(TestTelemetryCommand.run([])).resolves.toBe(EXPECTED_COMMAND_RESULT)
+
+          expect(fetchSpy.mock.calls.length).toEqual(1)
+
+          expect(fetchSpy.mock.calls[0][0]).toMatchInlineSnapshot(`"http://localhost:3000/"`)
+          expect(fetchSpy.mock.calls[0][1]?.body).toMatchInlineSnapshot(`
+            "
+            celocli_invocation{success="true", version="5.2.3", command="test:telemetry-timeout"} 1
+            "
+          `)
+          expect(fetchSpy.mock.calls[0][1]?.headers).toMatchInlineSnapshot(`
+                    {
+                      "Content-Type": "application/octet-stream",
+                    }
+                `)
+          expect(fetchSpy.mock.calls[0][1]?.method).toMatchInlineSnapshot(`"POST"`)
+          expect(fetchSpy.mock.calls[0][1]?.signal).toBeInstanceOf(AbortSignal)
+          // Make sure the request was aborted
+          expect(fetchSpy.mock.calls[0][1]?.signal?.aborted).toBe(true)
+
+          server.close()
+          resolve()
+        })
+      })
+    })
+  })
 })
diff --git a/packages/cli/src/base.ts b/packages/cli/src/base.ts
index a1b49f4c9..e76a920ef 100644
--- a/packages/cli/src/base.ts
+++ b/packages/cli/src/base.ts
@@ -15,6 +15,7 @@ import { CustomFlags } from './utils/command'
 import { getDefaultDerivationPath, getNodeUrl } from './utils/config'
 import { getFeeCurrencyContractWrapper } from './utils/fee-currency'
 import { requireNodeIsSynced } from './utils/helpers'
+import { reportUsageStatisticsIfTelemetryEnabled } from './utils/telemetry'
 
 export abstract class BaseCommand extends Command {
   static flags: FlagInput = {
@@ -252,6 +253,8 @@ export abstract class BaseCommand extends Command {
 
   async finally(arg: Error | undefined): Promise<any> {
     try {
+      await reportUsageStatisticsIfTelemetryEnabled(this.config.configDir, !arg, this.id)
+
       if (arg) {
         if (!(arg instanceof CLIError)) {
           console.error(
diff --git a/packages/cli/src/commands/config/get.test.ts b/packages/cli/src/commands/config/get.test.ts
index 11d73952d..b244a95e8 100644
--- a/packages/cli/src/commands/config/get.test.ts
+++ b/packages/cli/src/commands/config/get.test.ts
@@ -14,10 +14,11 @@ testWithAnvilL2('config:get cmd', (web3: Web3) => {
   it('shows the config', async () => {
     const logMock = jest.spyOn(console, 'log').mockImplementation()
     await testLocallyWithWeb3Node(Get, [], web3)
-    expect(stripAnsiCodesAndTxHashes(logMock.mock.calls[0][0].replace(/:\d\d\d\d/, ':PORT')))
+    expect(stripAnsiCodesAndTxHashes(logMock.mock.calls[0][0].replace(/:\d+/, ':PORT')))
       .toMatchInlineSnapshot(`
       "node: http://127.0.0.1:PORT
-      derivationPath: m/44'/52752'/0'"
+      derivationPath: m/44'/52752'/0'
+      telemetry: true"
     `)
   })
 })
diff --git a/packages/cli/src/commands/config/set.test.ts b/packages/cli/src/commands/config/set.test.ts
index 175806a00..bc73f5295 100644
--- a/packages/cli/src/commands/config/set.test.ts
+++ b/packages/cli/src/commands/config/set.test.ts
@@ -3,17 +3,32 @@ import { testWithAnvilL1 } from '@celo/dev-utils/lib/anvil-test'
 import { ux } from '@oclif/core'
 import Web3 from 'web3'
 import { stripAnsiCodesFromNestedArray, testLocallyWithWeb3Node } from '../../test-utils/cliUtils'
+import * as cliUtils from '../../utils/cli'
 import * as config from '../../utils/config'
+import Get from './get'
 import Set from './set'
 
 process.env.NO_SYNCCHECK = 'true'
 
-afterEach(async () => {
-  jest.clearAllMocks()
-  jest.restoreAllMocks()
-})
-
 testWithAnvilL1('config:set cmd', (web3: Web3) => {
+  afterEach(async () => {
+    jest.clearAllMocks()
+    jest.restoreAllMocks()
+
+    // cleanup to defaults after each test to have deterministic results
+    await testLocallyWithWeb3Node(
+      Set,
+      [
+        '--telemetry',
+        config.defaultConfig.telemetry ? '1' : '0',
+        '--derivationPath',
+        config.defaultConfig.derivationPath,
+        // node is injected by default by testLocallyWithWeb3Node
+      ],
+      web3
+    )
+  })
+
   describe('--derivationPath', () => {
     it('sets with bip44 path', async () => {
       const writeMock = jest.spyOn(config, 'writeConfig')
@@ -79,9 +94,57 @@ testWithAnvilL1('config:set cmd', (web3: Web3) => {
         ],
       ]
     `)
+
     expect(writeMock).toHaveBeenCalledTimes(1)
     expect(writeMock.mock.calls[0][0]).toMatch('.config/@celo/celocli')
     expect(writeMock.mock.calls[0][1]).toMatchObject({ derivationPath: "m/44'/52752'/0'" })
     expect(writeMock.mock.calls[0][1]).not.toHaveProperty('gasCurrency')
   })
+
+  it('allows to disable telemetry', async () => {
+    const writeMock = jest.spyOn(config, 'writeConfig')
+    const configDir = '.config/@celo/celocli'
+    const printValueMapSpy = jest.spyOn(cliUtils, 'printValueMap')
+
+    await testLocallyWithWeb3Node(Set, ['--telemetry', '0'], web3)
+
+    expect(writeMock).toHaveBeenCalledTimes(1)
+    expect(writeMock.mock.calls[0][0]).toMatch(configDir)
+    expect(writeMock.mock.calls[0][1]).toMatchObject({
+      telemetry: false,
+    })
+
+    await testLocallyWithWeb3Node(Get, [], web3)
+    expect(printValueMapSpy).toHaveBeenCalledTimes(1)
+    expect(printValueMapSpy.mock.calls[0][0].telemetry).toEqual(false)
+
+    // Setting other config value should not change telemetry
+    // In this case --node flag is passed by default so we don't
+    // need to specify any other flags
+    await testLocallyWithWeb3Node(Set, [], web3)
+
+    expect(writeMock).toHaveBeenCalledTimes(2)
+    expect(writeMock.mock.calls[1][0]).toMatch(configDir)
+    expect(writeMock.mock.calls[1][1]).toMatchObject({
+      telemetry: false,
+    })
+
+    // Check that it's not overwritten
+    await testLocallyWithWeb3Node(Get, [], web3)
+    expect(printValueMapSpy).toHaveBeenCalledTimes(2)
+    expect(printValueMapSpy.mock.calls[1][0].telemetry).toEqual(false)
+
+    // Now let's check if we can enable it back
+    await testLocallyWithWeb3Node(Set, ['--telemetry', '1'], web3)
+
+    expect(writeMock).toHaveBeenCalledTimes(3)
+    expect(writeMock.mock.calls[2][0]).toMatch(configDir)
+    expect(writeMock.mock.calls[2][1]).toMatchObject({
+      telemetry: true,
+    })
+
+    await testLocallyWithWeb3Node(Get, [], web3)
+    expect(printValueMapSpy).toHaveBeenCalledTimes(3)
+    expect(printValueMapSpy.mock.calls[2][0].telemetry).toEqual(true)
+  })
 })
diff --git a/packages/cli/src/commands/config/set.ts b/packages/cli/src/commands/config/set.ts
index 2192550b3..fdfff1e37 100644
--- a/packages/cli/src/commands/config/set.ts
+++ b/packages/cli/src/commands/config/set.ts
@@ -20,6 +20,11 @@ export default class Set extends BaseCommand {
       description:
         "Set the default derivation path used by account:new and when using --useLedger flag. Options: 'eth', 'celoLegacy', or a custom derivation path",
     }),
+    telemetry: Flags.string({
+      options: ['1', '0'],
+      description: 'Whether to enable or disable telemetry',
+      required: false,
+    }),
   }
 
   static examples = [
@@ -34,6 +39,8 @@ export default class Set extends BaseCommand {
     "set --derivationPath \"m/44'/52752'/0'/0\"",
     'set --derivationPath eth',
     'set --derivationPath celoLegacy',
+    'set --telemetry 0 # disable telemetry',
+    'set --telemetry 1 # enable telemetry',
   ]
 
   requireSynced = false
@@ -43,6 +50,8 @@ export default class Set extends BaseCommand {
     const curr = readConfig(this.config.configDir)
     const node = res.flags.node ?? curr.node
     const derivationPath = res.flags.derivationPath ?? curr.derivationPath
+    const telemetry =
+      res.flags.telemetry === '0' ? false : res.flags.telemetry === '1' ? true : curr.telemetry
     const gasCurrency = res.flags.gasCurrency
 
     if (gasCurrency) {
@@ -56,6 +65,7 @@ export default class Set extends BaseCommand {
     await writeConfig(this.config.configDir, {
       node,
       derivationPath,
+      telemetry,
     } as CeloConfig)
   }
 }
diff --git a/packages/cli/src/scripts/postinstall.ts b/packages/cli/src/scripts/postinstall.ts
new file mode 100644
index 000000000..8624f3106
--- /dev/null
+++ b/packages/cli/src/scripts/postinstall.ts
@@ -0,0 +1,3 @@
+import { printTelemetryInformation } from '../utils/telemetry'
+
+printTelemetryInformation()
diff --git a/packages/cli/src/test-utils/setup.ts b/packages/cli/src/test-utils/setup.ts
index 5dbb83c4f..dbf3f7dfa 100644
--- a/packages/cli/src/test-utils/setup.ts
+++ b/packages/cli/src/test-utils/setup.ts
@@ -11,3 +11,5 @@ jest.mock('@ledgerhq/hw-transport-node-hid', () => {
     },
   }
 })
+
+process.env.TELEMETRY_ENABLED = '0'
diff --git a/packages/cli/src/utils/config.test.ts b/packages/cli/src/utils/config.test.ts
index 16a85ecd2..b45f0fe33 100644
--- a/packages/cli/src/utils/config.test.ts
+++ b/packages/cli/src/utils/config.test.ts
@@ -30,16 +30,39 @@ describe('writeConfig', () => {
       {
         "derivationPath": "m/44'/52752'/0'",
         "node": "http://localhost:8545",
+        "telemetry": true,
       }
     `)
   })
   it('accepts node', async () => {
     const [dir] = getPaths()
-    await writeConfig(dir, { node: 'SOME_URL', derivationPath: "m/44'/52752'/0'/0/0" })
+    await writeConfig(dir, {
+      node: 'SOME_URL',
+      derivationPath: "m/44'/52752'/0'/0/0",
+      telemetry: true,
+    })
     expect(spy.mock.calls[0][1]).toMatchInlineSnapshot(`
       {
         "derivationPath": "m/44'/52752'/0'/0/0",
         "node": "SOME_URL",
+        "telemetry": true,
+      }
+    `)
+  })
+
+  it('accepts telemetry', async () => {
+    const [dir] = getPaths()
+    await writeConfig(dir, {
+      derivationPath: "m/44'/52752'/0'/0/0",
+      node: 'http://localhost:8545',
+      telemetry: false,
+    })
+
+    expect(spy.mock.calls[0][1]).toMatchInlineSnapshot(`
+      {
+        "derivationPath": "m/44'/52752'/0'/0/0",
+        "node": "http://localhost:8545",
+        "telemetry": false,
       }
     `)
   })
@@ -54,6 +77,7 @@ describe('readConfig', () => {
         "derivationPath": "m/44'/52752'/0'",
         "foo": "bar",
         "node": "http://localhost:8545",
+        "telemetry": true,
       }
     `)
   })
@@ -64,6 +88,7 @@ describe('readConfig', () => {
       {
         "derivationPath": "m/44'/52752'/0'",
         "node": "bar",
+        "telemetry": true,
       }
     `)
   })
@@ -74,6 +99,7 @@ describe('readConfig', () => {
       {
         "derivationPath": "m/44'/52752'/0'",
         "node": "http://localhost:8545",
+        "telemetry": true,
       }
     `)
   })
diff --git a/packages/cli/src/utils/config.ts b/packages/cli/src/utils/config.ts
index 2085cb9df..6c183d507 100644
--- a/packages/cli/src/utils/config.ts
+++ b/packages/cli/src/utils/config.ts
@@ -5,6 +5,7 @@ import * as path from 'path'
 export interface CeloConfig {
   node: string
   derivationPath: string
+  telemetry: boolean
 }
 
 // NOTE: this mapping should stay updated as CeloConfig evolves
@@ -16,6 +17,7 @@ const LEGACY_MAPPING: Record<string, keyof CeloConfig | undefined> = {
 export const defaultConfig: CeloConfig = {
   node: 'http://localhost:8545',
   derivationPath: CELO_DERIVATION_PATH_BASE,
+  telemetry: true,
 }
 
 const configFile = 'config.json'
@@ -57,5 +59,6 @@ export async function writeConfig(configDir: string, configObj: CeloConfig) {
   fs.outputJSONSync(configPath(configDir), {
     node: config.node,
     derivationPath: config.derivationPath,
+    telemetry: config.telemetry,
   })
 }
diff --git a/packages/cli/src/utils/telemetry.test.ts b/packages/cli/src/utils/telemetry.test.ts
new file mode 100644
index 000000000..964d4a278
--- /dev/null
+++ b/packages/cli/src/utils/telemetry.test.ts
@@ -0,0 +1,33 @@
+import { ux } from '@oclif/core'
+import { stripAnsiCodesFromNestedArray } from '../test-utils/cliUtils'
+import { printTelemetryInformation } from './telemetry'
+
+describe('telemetry', () => {
+  it('prints the information', () => {
+    const writeMock = jest.spyOn(ux.write, 'stdout')
+
+    printTelemetryInformation()
+
+    expect(stripAnsiCodesFromNestedArray(writeMock.mock.calls)).toMatchInlineSnapshot(`
+      [
+        [
+          "
+      celocli is now gathering anonymous usage statistics. 
+          
+      None of the data being collected is personally identifiable and no flags or arguments are being stored nor transmitted.
+                
+      Data being reported is:
+        - command (for example network:info)
+        - celocli version (for example 5.2.3)
+        - success status (true/false)
+                
+      If you would like to opt out of this data collection, you can do so by running:
+          
+      celocli config:set --telemetry 0
+          
+      ",
+        ],
+      ]
+    `)
+  })
+})
diff --git a/packages/cli/src/utils/telemetry.ts b/packages/cli/src/utils/telemetry.ts
new file mode 100644
index 000000000..1ac21fe88
--- /dev/null
+++ b/packages/cli/src/utils/telemetry.ts
@@ -0,0 +1,126 @@
+import { ux } from '@oclif/core'
+import chalk from 'chalk'
+import fs from 'fs'
+import path from 'path'
+import packageJson from '../../package.json'
+import { readConfig } from './config'
+
+const debug = require('debug')('celocli:telemetry')
+
+export type TelemetryOptions = {
+  command: string
+  success: boolean
+  version: string
+}
+
+const getTelemetryOptions = (command: string, success: boolean): TelemetryOptions => {
+  return {
+    command,
+    success,
+    version: packageJson.version,
+  }
+}
+
+const TELEMETRY_TIMEOUT = 1000 // 1 second
+const TELEMETRY_PRINTED_FILE = '.telemetry'
+const TELEMETRY_URL = 'https://pag.mainnet.celo-testnet.org/metrics'
+
+const UNKNOWN_COMMAND = '_unknown'
+
+const telemetryInformationAlreadyPrinted = (configDir: string) => {
+  try {
+    return fs.existsSync(path.join(configDir, TELEMETRY_PRINTED_FILE))
+  } catch (err) {
+    debug(`Failed to check if .telemetry file exists: ${err}`)
+  }
+
+  return false
+}
+
+const markTelemetryInformationAsPrinted = (configDir: string) => {
+  try {
+    fs.writeFileSync(path.join(configDir, TELEMETRY_PRINTED_FILE), '')
+  } catch (err) {
+    debug(`Failed to write .telemetry file: ${err}`)
+  }
+}
+
+export const reportUsageStatisticsIfTelemetryEnabled = (
+  configDir: string,
+  success: boolean,
+  command: string = UNKNOWN_COMMAND
+) => {
+  if (process.env.TELEMETRY_ENABLED === '0') {
+    return
+  }
+
+  const config = readConfig(configDir)
+
+  if (config.telemetry === true) {
+    const telemetry = getTelemetryOptions(command, success)
+
+    // Only show the information upon first usage
+    if (!telemetryInformationAlreadyPrinted(configDir)) {
+      printTelemetryInformation()
+      markTelemetryInformationAsPrinted(configDir)
+    }
+
+    const telemetryData = `celocli_invocation{success="${
+      telemetry.success ? 'true' : 'false'
+    }", version="${telemetry.version}", command="${telemetry.command}"} 1`
+
+    debug(`Sending telemetry data: ${telemetryData}`)
+
+    const controller = new AbortController()
+    const timeout = setTimeout(() => {
+      controller.abort()
+    }, TELEMETRY_TIMEOUT)
+
+    return fetch(process.env.TELEMETRY_URL ?? TELEMETRY_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/octet-stream',
+      },
+      signal: controller.signal,
+      body: `
+${telemetryData}
+`,
+    })
+      .then((response) => {
+        clearTimeout(timeout)
+
+        if (!response.ok && response.body) {
+          debug(`Failed to send telemetry data: ${response.statusText}`)
+
+          return
+        }
+
+        debug(`Telemetry data sent successfuly`)
+      })
+      .catch((err) => {
+        debug(`Failed to send telemetry data: ${err}`)
+      })
+  } else {
+    debug('Telemetry is disabled')
+  }
+}
+
+export const printTelemetryInformation = () => {
+  ux.info(
+    chalk.green(
+      `\ncelocli is now gathering anonymous usage statistics. 
+    
+None of the data being collected is personally identifiable and no flags or arguments are being stored nor transmitted.
+          
+Data being reported is:
+  - command (for example ${chalk.bold('network:info')})
+  - celocli version (for example ${chalk.bold('5.2.3')})
+  - success status (true/false)
+          
+If you would like to opt out of this data collection, you can do so by running:
+    
+${chalk.bold('celocli config:set --telemetry 0')}
+    `
+    )
+  )
+}