Connection Guide

Parts of a Connection URI

The following example explains each part of a sample connection URI:

In this example, we use mongodb for the protocol, which specifies the Standard Connection String Format. You can also use the DNS Seed List Connection Format if you want more flexibility of deployment and the ability to change the servers in rotation without reconfiguring clients.

The next part of the connection string contains your database username and, if you are using password-based authentication, your password. Replace the value of user with your database username and pass with your password. If you are using an authentication mechanism that does not require a username and password, omit this part of the connection URI.

The next part of the connection string specifies the hostname or IP address and port of your MongoDB instance. In the preceding example, we use sample.host as the hostname and 27017 as the port. Replace these values to point to your MongoDB instance.

The last part of the connection string specifies connection and authentication options. In the example, we set two connection options: maxPoolSize=20 and w=majority. To learn more about connection options, read the Connection Options section of this guide.

Connection Example

To connect to MongoDB, you must create a client. A client manages your connections and runs database commands.

You can create a client that uses your connection string and other client options by passing a ClientOptions object to the Connect() method.

To specify your connection URI, pass it to the ApplyURI() method, which returns a new ClientOptions instance. To set any other options, call the relevant helper method from the options package.

To learn more about connection options, see the Connection Options section. To learn more about creating a client, see the API documentation for Client and Connect().

You can set the Stable API version as an option to avoid breaking changes when you upgrade to a new server version. To learn more about the Stable API feature, see the Stable API page.

The following code shows how you can create a client that uses an Atlas connection string and the Stable API version, connect to MongoDB, and verify that the connection is successful:

// Connects to MongoDB and sets a Stable API version
package main
import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)
// Replace the placeholder with your Atlas connection string
const uri = "<connection string>"
func main() {
	// Use the SetServerAPIOptions() method to set the Stable API version to 1
	serverAPI := options.ServerAPI(options.ServerAPIVersion1)
	opts := options.Client().ApplyURI(uri).SetServerAPIOptions(serverAPI)
	// Create a new client and connect to the server
	client, err := mongo.Connect(context.TODO(), opts)
	if err != nil {
		panic(err)
	}
	defer func() {
		if err = client.Disconnect(context.TODO()); err != nil {
			panic(err)
		}
	}()
	// Send a ping to confirm a successful connection
	var result bson.M
	if err := client.Database("admin").RunCommand(context.TODO(), bson.D{{"ping", 1}}).Decode(&result); err != nil {
		panic(err)
	}
	fmt.Println("Pinged your deployment. You successfully connected to MongoDB!")
}

Connect to a MongoDB Server on Your Local Machine

If you must run a MongoDB server on your local machine for development purposes, complete the following steps:

1. Download the Community or Enterprise version of MongoDB Server.

2. Install and configure MongoDB Server.

3. Start the server.

After you successfully start your MongoDB server, specify your connection string in your driver connection code.

If your MongoDB Server is running locally, you can use the connection string "mongodb://localhost:<port>" where <port> is the port number you configured your server to listen for incoming connections.

If you want to specify a different hostname or IP address, see our Server Manual entry on Connection Strings.

To test whether you can connect to your server, replace the connection string with your localhost connection string in the preceding code example.

Connect to a Replica Set

A MongoDB replica set deployment is a group of connected instances that store the same set of data. This configuration provides data redundancy and high data availability.

To connect to a replica set deployment, specify the hostname and port numbers of each instance, separated by commas, and the replica set name as the value of the replicaSet parameter in the connection string. In the following example, the hostnames are host1, host2, and host3, and the port numbers are all 27017. The replica set name is myRS.

mongodb://host1:27017,host2:27017,host3:27017/?replicaSet=myRS

When connecting to a replica set, the driver takes the following actions by default:

• Discovers all replica set members when given the address of any one member.

• Dispatches operations to the appropriate member, such as instructions to write against the primary.

Single Timeout Setting

You can set a single Timeout option on your Client to govern the amount of time that a single operation can take to execute using the SetTimeout() method or specifying the timeoutMS option in your connection URI string. Database, Collection, Session, ChangeStream, and Bucket instances elsewhere in your code inherit the Timeout option from Client if you do not set a Context for operations against the same entity.

If you pass a Context into an operation with a deadline, the driver uses that Context deadline for the operation. If the context does not have a deadline, the driver derives a new Context from the given Context using the Timeout option set on the Client.

The following code shows how to set the Timeout option on a Client with the SetTimeout option:

opts := options.Client().SetTimeout(5 * time.Second)

The following example shows how you can set a single timeout with the URI option and execute an operation that inherits this setting:

uri := "mongodb://user:pass@sample.host:27017/?timeoutMS=5000"
client := mongo.Connect(context.TODO(), uri)
coll := client.Database("<db>").Collection("<collection>")
...
coll.InsertOne(context.Background(), doc)