• Version 14.2.1
  • Published
  • 24.2 MB
  • 66 dependencies
  • Apache-2.0 license


npm i bitgo
yarn add bitgo
pnpm add bitgo


BitGo JavaScript SDK



variable Environments

const Environments: common.Environments;

    variable GlobalCoinFactory

    const GlobalCoinFactory: CoinFactory;

      variable sjcl

      const sjcl: any;
      • Deprecated


      function getNetwork

      getNetwork: () => any;
      • Get the network. Returns either "bitcoin" or "testnet".


      function getNetworkObj

      getNetworkObj: () => utxolib.Network;
      • Deprecated

      function setNetwork

      setNetwork: (network: any) => void;
      • Set the network, i.e. either "bitcoin" for production with real bitcoin, or "testnet" for development with testnet bitcoin.



      class BitGo

      class BitGo extends BitGoAPI {}


        constructor(params?: BitGoAPIOptions);
        • Constructor for BitGo Object

        method coin

        coin: (coinName: string) => BaseCoin;
        • Create a basecoin object

          Parameter coinName

        method token

        token: (tokenName: string) => Promise<BaseCoin>;
        • Create a basecoin object for a virtual token

          Parameter tokenName

        Type Aliases

        type BitGoOptions

        type BitGoOptions = BitGoAPIOptions;


          namespace bitcoin

          module 'dist/types/src/legacyBitcoin.d.ts' {}
          • Implementation of legacy "HDNode" class as used by certain components

          variable address

          const address: {
          fromBase58Check(addr: string): { hash: Buffer; version: number };
          toBase58Check(hash: Buffer, version: number): string;

            variable networks

            const networks: Record<utxolib.NetworkName, utxolib.Network>;

              function hdPath

              hdPath: (hdNode: HDNode) => Derivable;

                function makeRandomKey

                makeRandomKey: () => ECPairCompat;

                  class HDNode

                  class HDNode {}
                  • Implementation of legacy "HDNode" class as used by certain components


                  constructor(bip32: bip32.BIP32Interface);

                    property privateKey

                    readonly privateKey: any;

                      property publicKey

                      readonly publicKey: Buffer;

                        method derivePath

                        derivePath: (p: string) => HDNode;

                          method fromBase58

                          static fromBase58: (str: string) => HDNode;

                            method fromSeedBuffer

                            static fromSeedBuffer: (buf: Buffer) => HDNode;

                              method isNeutered

                              isNeutered: () => boolean;

                                method neutered

                                neutered: () => HDNode;

                                  method toBase58

                                  toBase58: () => string;

                                    interface Derivable

                                    interface Derivable {}

                                      method derive

                                      derive: (path: string) => HDNode;

                                        method deriveKey

                                        deriveKey: (path: string) => ECPairCompat;

                                          namespace Coin

                                          module 'dist/types/src/v2/coins/index.d.ts' {}

                                            variable FiatEur

                                            const FiatEur: any;

                                              variable FiatGBP

                                              const FiatGBP: any;

                                                variable FiatUsd

                                                const FiatUsd: any;

                                                  variable Ofc

                                                  const Ofc: any;

                                                    variable OfcToken

                                                    const OfcToken: any;

                                                      variable Susd

                                                      const Susd: any;

                                                        variable TfiatEur

                                                        const TfiatEur: any;

                                                          variable TfiatGBP

                                                          const TfiatGBP: any;

                                                            variable TfiatUsd

                                                            const TfiatUsd: any;

                                                              variable Tsusd

                                                              const Tsusd: any;

                                                                Package Files (5)

                                                                Dependencies (66)

                                                                Dev Dependencies (20)

                                                                Peer Dependencies (0)

                                                                No peer dependencies.


                                                                To add a badge like this badgeto your package's README, use the codes available below.

                                                                You may also use to create a custom badge linking to

                                                                • Markdown
                                                                • HTML
                                                                  <a href=""><img src="" alt=""></a>