How to Integrate Replit with MongoDB Atlas

This is the most important step and the #1 reason developers cannot connect to MongoDB Atlas from Replit. By default, Atlas only allows connections from IPs you explicitly whitelist. Replit does not provide static outbound IP addresses — your server's IP changes every time the Repl restarts, scales up, or gets a new container. This means you cannot add a single IP address and rely on it. To allow Replit to connect, you must whitelist all IPs: log into MongoDB Atlas at cloud.mongodb.com, select your project, and click 'Network Access' in the left sidebar under Security. Click the green 'Add IP Address' button. In the dialog, click 'Allow Access from Anywhere' — this fills in 0.0.0.0/0 with a /0 subnet mask. Add a comment like 'Replit dynamic IPs' so you remember why this is set. Click 'Confirm.' Atlas will show a 'Pending' status for about 30 seconds while the change propagates globally. Wait for it to turn 'Active' before testing your connection. Security note: Opening to all IPs is not ideal, but it is the standard approach for dynamic-IP cloud platforms like Replit, Heroku, and Railway. Protect your database by using a strong Atlas username and password, limiting the database user's permissions to only the specific database it needs, and never exposing your connection string in client-side code. Some teams use a VPN proxy service like QuotaGuard to get a static IP if they need stricter access control on sensitive production data.

Your MongoDB connection string contains your username, password, and cluster hostname. It must never appear in code or be committed to Git. Replit Secrets is the correct place to store it — secrets are AES-256 encrypted, injected as environment variables at runtime, and never included in version control. To get your connection string: in Atlas, click your cluster name, then click 'Connect'. Choose 'Connect your application'. Select your driver (Node.js or Python) and the latest version. Atlas generates a connection string that looks like: mongodb+srv://username:password@cluster0.abc123.mongodb.net/?retryWrites=true&w=majority. Copy it and replace the placeholder password with your actual database user password. Also append your database name before the query string: mongodb+srv://username:password@cluster0.abc123.mongodb.net/myDatabase?retryWrites=true&w=majority. Now open your Repl. Click the lock icon (🔒) in the left sidebar — this opens the Secrets pane. Click 'New Secret'. Set the key to MONGODB_URI and paste your full connection string as the value. Click 'Add Secret'. This secret is now available in your code as process.env.MONGODB_URI (Node.js) or os.environ['MONGODB_URI'] (Python). Do not create a .env file and commit it. Do not hardcode the string in any source file. Replit's Secret Scanner will flag hardcoded credentials, but it's best practice to use Secrets from the start.

1# Verify your secret is accessible (Python)
2import os
3
4uri = os.environ.get('MONGODB_URI')
5if not uri:
6    raise ValueError('MONGODB_URI secret is not set. Add it in the Secrets pane (lock icon).')
7print('Connection string found:', uri[:30] + '...')  # Print only first 30 chars

For Node.js projects, you have two options: the low-level official MongoDB driver (mongodb package) or Mongoose, an ODM (Object Document Mapper) that adds schema validation, middleware hooks, and a more structured API. Mongoose is recommended for applications with defined data models; the raw driver is better for flexible queries or when you want minimal abstraction. In your Repl's Shell tab, run: npm install mongoose. This installs Mongoose and its dependency on the mongodb driver. Alternatively, for the raw driver: npm install mongodb. The connection pattern below uses Mongoose with proper connection pooling. The key settings for Replit deployments are serverSelectionTimeoutMS (how long to wait when Atlas is unreachable — set to 5 seconds to fail fast) and the connect-once pattern where you establish the connection at startup and reuse it across requests. Never open a new connection per request — this exhausts your Atlas cluster's connection limit quickly. For Autoscale deployments, connections may be closed between invocations. The code below handles reconnection automatically through Mongoose's built-in reconnect logic.

1// server.js — Express + Mongoose on Replit
2const express = require('express');
3const mongoose = require('mongoose');
4
5const app = express();
6app.use(express.json());
7
8// Connect to MongoDB Atlas once at startup
9async function connectDB() {
10  try {
11    await mongoose.connect(process.env.MONGODB_URI, {
12      serverSelectionTimeoutMS: 5000,  // Fail fast if Atlas unreachable
13      maxPoolSize: 10,                  // Max concurrent connections
14    });
15    console.log('Connected to MongoDB Atlas');
16  } catch (err) {
17    console.error('MongoDB connection failed:', err.message);
18    process.exit(1);  // Exit so Replit can restart cleanly
19  }
20}
21
22// Define a simple schema
23const itemSchema = new mongoose.Schema({
24  name: { type: String, required: true },
25  value: mongoose.Schema.Types.Mixed,  // Accepts any data type
26  createdAt: { type: Date, default: Date.now }
27});
28const Item = mongoose.model('Item', itemSchema);
29
30// CRUD routes
31app.get('/items', async (req, res) => {
32  try {
33    const items = await Item.find().sort({ createdAt: -1 }).limit(50);
34    res.json(items);
35  } catch (err) {
36    res.status(500).json({ error: err.message });
37  }
38});
39
40app.post('/items', async (req, res) => {
41  try {
42    const item = new Item(req.body);
43    await item.save();
44    res.status(201).json(item);
45  } catch (err) {
46    res.status(400).json({ error: err.message });
47  }
48});
49
50app.delete('/items/:id', async (req, res) => {
51  try {
52    await Item.findByIdAndDelete(req.params.id);
53    res.json({ deleted: true });
54  } catch (err) {
55    res.status(500).json({ error: err.message });
56  }
57});
58
59// Health check endpoint
60app.get('/health', (req, res) => {
61  const state = mongoose.connection.readyState;
62  const states = { 0: 'disconnected', 1: 'connected', 2: 'connecting', 3: 'disconnecting' };
63  res.json({ status: states[state] || 'unknown' });
64});
65
66// Start server on 0.0.0.0 so Replit can route traffic
67connectDB().then(() => {
68  app.listen(3000, '0.0.0.0', () => {
69    console.log('Server running on port 3000');
70  });
71});

For Python Replit projects using Flask or FastAPI, PyMongo is the synchronous MongoDB driver and Motor is the async version (recommended with FastAPI). Both accept the same mongodb+srv:// connection string from your environment variables. Install the driver: in the Shell tab, run pip install pymongo or pip install motor (for async). For Flask with PyMongo, the setup below creates a single MongoClient instance at module level. This is intentional — MongoClient is thread-safe and manages its own connection pool internally. Creating a new MongoClient per request is a common mistake that causes connection exhaustion. The tldr attribute from the MongoDB URI already specifies the database. You can access it with client.get_default_database() or reference it directly with client['yourDbName']. Collections are accessed as attributes: db.users, db.products, etc. For production Flask apps on Replit, deploy as an Autoscale deployment. If you use change streams or need a persistent long-lived connection, use Reserved VM instead, as Autoscale containers may be destroyed between requests during low-traffic periods.

1# app.py — Flask + PyMongo on Replit
2from flask import Flask, request, jsonify
3from pymongo import MongoClient
4from pymongo.errors import ConnectionFailure, OperationFailure
5from bson import ObjectId
6from bson.json_util import dumps
7import os
8import json
9
10app = Flask(__name__)
11
12# Connect once at module load — MongoClient manages its own pool
13try:
14    client = MongoClient(
15        os.environ['MONGODB_URI'],
16        serverSelectionTimeoutMS=5000
17    )
18    # Verify connection is alive
19    client.admin.command('ping')
20    db = client.get_default_database()
21    print('Connected to MongoDB Atlas')
22except ConnectionFailure as e:
23    print(f'MongoDB connection failed: {e}')
24    raise
25
26@app.route('/items', methods=['GET'])
27def get_items():
28    items = list(db.items.find({}, {'_id': 1, 'name': 1, 'value': 1}))
29    # Convert ObjectId to string for JSON serialization
30    for item in items:
31        item['_id'] = str(item['_id'])
32    return jsonify(items)
33
34@app.route('/items', methods=['POST'])
35def create_item():
36    data = request.get_json()
37    if not data or 'name' not in data:
38        return jsonify({'error': 'name is required'}), 400
39    result = db.items.insert_one(data)
40    return jsonify({'_id': str(result.inserted_id)}), 201
41
42@app.route('/items/<item_id>', methods=['DELETE'])
43def delete_item(item_id):
44    result = db.items.delete_one({'_id': ObjectId(item_id)})
45    if result.deleted_count == 0:
46        return jsonify({'error': 'Not found'}), 404
47    return jsonify({'deleted': True})
48
49@app.route('/health')
50def health():
51    try:
52        client.admin.command('ping')
53        return jsonify({'status': 'connected'})
54    except Exception as e:
55        return jsonify({'status': 'error', 'message': str(e)}), 503
56
57if __name__ == '__main__':
58    app.run(host='0.0.0.0', port=3000)

After verifying your connection works in development mode, deploy your app so it runs 24/7 independent of your editor session. Development mode Repls sleep when you close the browser — any scheduled jobs or webhook handlers stop working. Deployed apps stay live based on their deployment type. For most MongoDB-backed web APIs, choose Autoscale Deployment. Autoscale scales between zero and N replicas based on traffic, meaning you pay only for actual usage. The trade-off is a cold start on the first request after a quiet period — typically 1-3 seconds. This is acceptable for most apps since MongoDB Atlas also uses connection pooling that handles reconnection transparently. For apps that use MongoDB Change Streams (real-time document watchers), background job workers, or scheduled tasks, choose Reserved VM Deployment. Reserved VMs run continuously on a fixed container, maintaining a persistent MongoDB connection without cold starts. Reserved VMs cost more but are essential for always-on workloads. To deploy: click the 'Deploy' button in the top-right of the Replit editor. Select your deployment type. Make sure your .replit file specifies the correct run command and port configuration. After deployment, your app gets a stable URL at https://yourapp.replit.app — use this URL for any external service integrations, webhook registrations, or API endpoint references. Secrets set in your workspace are automatically available in deployments.

1# .replit configuration for deployment
2# Add this to your .replit file
3
4# [[ports]]
5# internalPort = 3000
6# externalPort = 80
7#
8# [deployment]
9# run = ["node", "server.js"]
10# deploymentTarget = "cloudrun"
11
12# For Python:
13# [deployment]
14# run = ["python", "app.py"]
15# deploymentTarget = "cloudrun"