api.md

title	description
Advanced Kubo Usage	Developer resources for working in Go with IPFS, the InterPlanetary File System.

Advanced Kubo Usage

Working with Go

Kubo (go-ipfs) is the oldest implementation of IPFS. It is a command-line application, but can also be used as a library in other Go programs.

For more about using Kubo, see any of the following reference documents:

• Configuration reference
  • Datastore configuration
  • Experimental features
• Installing command completion
• Mounting IPFS with FUSE
• Installing plugins

For more technical information about building, debugging or using the API, see:

• Performance Debugging Guidelines
• IPFS API Implementation
• Connecting with Websockets
• Building on Windows
• Additional guides

If you plan to use Kubo as a package in your own Go application, you can take any of three main approaches:

• Use kubo to run Kubo IPFS directly in your own process.
• Use kubo RPC client to communicate with a Kubo IPFS daemon in a separate process via its HTTP RPC API (this is what Kubo does if a daemon is already running).
• Use other Go packages to communicate with the HTTP RPC API directly. See the RPC API reference.

Go CoreAPI

CoreAPI interfaces for go-ipfs. Package iface defines IPFS Core API, which is a set of interfaces used to interact with IPFS nodes.

Go embedded client

Package coreapi provides direct access to the core commands in IPFS. If you are embedding IPFS directly in your Go program, this package is the public interface you should use to read and write files or otherwise control IPFS. This package is experimental and subject to change.

If you are running IPFS as a separate process, you should use go-ipfs-api to work with it via RPC. As we finalize the interfaces in this embedded client, go-ipfs-api will transparently adopt them so you can use the same code with either package.

Go HTTP clients

CoreAPI implementation using HTTP API. This package is experimental and subject to change. For an old but stable Go HTTP client, use CoreAPI interfaces.

Packages

This table is generated using the module package-table with package-table --data=package-list.json.

Listing of the main go packages in the IPFS ecosystem:

Name	Go Reference	Coverage	Description
Libp2p
go-libp2p			p2p networking library
go-libp2p-pubsub			pubsub built on libp2p
go-libp2p-kad-dht			dht-backed router
go-libp2p-pubsub-router			pubsub-backed router
Multiformats
go-cid			CID implementation
go-multiaddr			multiaddr implementation
go-multihash			multihash implementation
go-multibase			mulitbase implementation
Files
go-unixfs			the core 'filesystem' logic
go-mfs			a mutable filesystem editor for unixfs
go-ipfs-posinfo			helper datatypes for the filestore
go-ipfs-chunker			file chunkers
Exchange
go-ipfs-exchange-interface			exchange service interface
go-ipfs-exchange-offline			(dummy) offline implementation of the exchange service
go-bitswap			bitswap protocol implementation
go-blockservice			service that plugs a blockstore and an exchange together
Datastores
go-datastore			datastore interfaces, adapters, and basic implementations
go-ipfs-ds-help			datastore utility functions
go-ds-flatfs			a filesystem-based datastore
go-ds-measure			a metric-collecting database adapter
go-ds-leveldb			a leveldb based datastore
go-ds-badger			a badgerdb based datastore
Namesys
go-ipns			IPNS datastructures and validation logic
Repo
go-fs-lock			lockfile management functions
fs-repo-migrations			repo migrations
IPLD
go-block-format			block interfaces and implementations
go-ipfs-blockstore			blockstore interfaces and implementations
go-ipld-format			IPLD interfaces
go-ipld-cbor			IPLD-CBOR implementation
go-ipld-git			IPLD-Git implementation
go-merkledag			IPLD-Merkledag implementation (and then some)
Commands
go-ipfs-cmds			CLI & HTTP commands library
go-ipfs-files			CLI & HTTP commands library
go-ipfs-api			an old, stable shell for the IPFS HTTP API
go-ipfs-http-client			a new, unstable shell for the IPFS HTTP API
interface-go-ipfs-core			core go-ipfs API interface definitions
Metrics & Logging
go-metrics-interface			metrics collection interfaces
go-metrics-prometheus			prometheus-backed metrics collector
go-log			logging framework
Generics/Utils
go-ipfs-routing			routing (content, peer, value) helpers
go-ipfs-util			the kitchen sink
go-ipfs-addr			utility functions for parsing IPFS multiaddrs

Hands-on examples

There are use-case examples in the ipfs/kubo GitHub repository. They're all self-contained projects that let your spin up and test environments quickly. Check them out →.

A good starting place is the Use kubo as a library to spawn a node and add a file.