Articles

Fix MongoDB Text Index Command Conflict Error (2026)

April 18, 2026 7 min read

The text index command failed because a text index already exists on the same collection, and you’re trying to create another one with a different configuration. MongoDB only allows a single text index per collection.

Here’s why this happens and how to fix it, covering all the likely scenarios:

1. Inspecting Existing Text Indexes

Before you can fix anything, you need to see what text indexes are already there.

Diagnosis:

db.collection.getIndexes()

Explanation: This command lists all indexes on the specified collection. Look for entries where the "2dsphere" or "2d" type is "text".

2. The Most Common Cause: Duplicate Creation

You ran the createIndex command for a text index, and then ran it again, perhaps with a slight variation in options or field names, before the first one fully completed or before you realized it was already there.

Diagnosis: Run db.collection.getIndexes() as shown above. You’ll see an entry like this:

{
    "name" : "title_text_description_text",
    "key" : {
        "title" : "text",
        "description" : "text"
    },
    "weights" : {
        "title" : 1,
        "description" : 1
    },
    "default_language" : "none",
    "language_override" : "language",
    "textIndexVersion" : 3
}

If you try to create another text index, even on the same fields, you’ll get the conflict.

Fix: If the existing index is exactly what you want, do nothing. If you need to modify it, you must drop the existing one and recreate it with your desired configuration.

To drop the existing index:

db.collection.dropIndex("title_text_description_text")

Replace "title_text_description_text" with the actual name of the index from getIndexes().

Then, recreate it with your desired configuration:

db.collection.createIndex(
    { title: "text", description: "text" },
    { weights: { title: 10, description: 5 }, default_language: "english", name: "my_custom_text_index" }
)

This command creates a new text index with specific weights and a default language. The name option is good practice to avoid future naming conflicts.

Why it works: Dropping the old index removes the conflict. Recreating it with the new createIndex command establishes the single, desired text index.

3. Accidental Creation of a Second Text Index on Different Fields

You might have created a text index on one set of fields and then later, without realizing, created another text index on a different set of fields.

Diagnosis: Again, use db.collection.getIndexes(). You’ll see multiple entries with "key" objects where one field is "text". For example:

[
    {
        "name" : "title_text",
        "key" : {
            "title" : "text"
        },
        // ... other text index options
    },
    {
        "name" : "body_text",
        "key" : {
            "body" : "text"
        },
        // ... other text index options
    }
]

Fix: Decide which text index is the correct one for your application. If you need to combine fields, you’ll drop all but one and then create a new, consolidated index.

To drop one of the conflicting indexes:

db.collection.dropIndex("body_text")

Or, if you want to keep body_text and drop title_text:

db.collection.dropIndex("title_text")

If you need a single index covering both title and body:

  1. Drop all existing text indexes.
    db.collection.dropIndex("title_text")
db.collection.dropIndex("body_text")
  2. Create a new, consolidated text index.
    db.collection.createIndex(
    { title: "text", body: "text" },
    { weights: { title: 5, body: 1 }, name: "content_text_index" }
)

Why it works: MongoDB enforces the one-text-index-per-collection rule. By consolidating or selecting one, you adhere to this rule.

4. Text Index Implicitly Created by Other Operations

Sometimes, other MongoDB operations or drivers might implicitly create a text index if not explicitly prevented. This is less common but possible.

Diagnosis: Examine the output of db.collection.getIndexes() very carefully. Look for any index that might have been created without your direct createIndex command. Also, check your application code and any scripts that interact with the database.

Fix: If an unexpected text index is found:

  1. Identify the source: Determine which part of your application or a tool created it.
  2. Drop the index:
    db.collection.dropIndex("unexpected_text_index_name")
  3. Prevent re-creation: Modify the application code or tool configuration to avoid creating it again. For example, if using Mongoose, ensure you don’t have multiple text indexes defined in your schema.

Why it works: Removing the unwanted index resolves the conflict. Preventing its re-creation ensures the problem doesn’t recur.

5. Text Index in a Sharded Collection (Advanced)

In sharded environments, while the rule of one text index per collection still applies at the collection level, managing it across shards requires careful attention. A conflict can arise if the text index creation is attempted on a sharded collection that isn’t properly set up or if there are inconsistencies.

Diagnosis: Use db.collection.getIndexes() on the mongos instance. Also, check the config database for sharding information.

use config
db.collections.findOne({ _id: "your_db.your_collection" })

Look for partialIndexes which can sometimes be confused with text indexes, though they are distinct. The primary issue here is more about the process of creating or dropping on a sharded collection.

Fix: Ensure that sharding is properly enabled and balanced for the collection before attempting to create or drop indexes. If you need to modify a text index on a sharded collection:

  1. Disable sharding for the collection (if possible and the collection isn’t too large, this is often not feasible).
  2. Drop the index on all shards individually if direct shard access is available.
  3. Recreate the index from the mongos instance.
  4. Re-enable sharding if it was disabled.

A more common approach for sharded collections is to ensure the index is created before sharding is enabled, or to perform index operations during maintenance windows.

If you need to drop a text index on a sharded collection:

# From mongos
db.collection.dropIndex("existing_text_index_name")

MongoDB will distribute this drop operation to all shards. If it fails, it might indicate an imbalance or an issue with the sharding metadata.

Why it works: Index operations on sharded collections are managed by mongos, which distributes the commands to each shard. Ensuring consistency across shards is key.

6. Driver/ORM Specific Issues

Some Object-Relational Mappers (ORMs) or database drivers might have their own internal logic for managing indexes. If not configured carefully, they can lead to duplicate text index declarations or attempts to recreate an existing one.

Diagnosis: Review your application’s ORM configuration (e.g., Mongoose schemas, Django models) or the code that directly interacts with MongoDB’s createIndex command. Look for multiple definitions of a text index or logic that might re-run createIndex unnecessarily.

Fix: Correct the ORM schema definition to have only one text index. For example, in Mongoose, ensure your schema defines only one text index property:

const mongoose = require('mongoose');
const Schema = mongoose.Schema;

const mySchema = new Schema({
  title: { type: String, text: true }, // Mark as text indexed
  body: { type: String, text: true },  // Mark as text indexed
  // ...other fields
});

// Ensure only ONE text index is defined on the schema.
// If you need weights, you define them like this for a single text index:
const mySchemaWithWeights = new Schema({
  title: { type: String },
  body: { type: String },
  // ...other fields
}, {
  text: {
    index: true,
    weights: {
      title: 10,
      body: 5
    },
    default_language: 'english'
  }
});

// If you have multiple text indexes defined (e.g., on different schemas or accidentally repeated),
// the driver might try to create them and cause a conflict.
// The fix is to consolidate or remove redundant definitions in your schema.

// You might need to drop existing conflicting indexes from the DB if the schema was fixed after creation:
// db.collection.dropIndex("title_text")
// db.collection.dropIndex("body_text")
// Then let the ORM recreate the correct consolidated one.

const MyModel = mongoose.model('MyModel', mySchemaWithWeights);

If using a raw driver, ensure your code only calls createIndex once for a text index.

Why it works: ORMs abstract index management. Correcting the schema definition ensures the ORM generates the correct, single createIndex command for MongoDB.

The next error you’ll likely encounter after fixing this is related to insufficient memory for the index build if the collection is very large, or potentially a different index conflict if you have other types of indexes that are also overlapping in their definition.

Want structured learning?

Take the full Mongodb course →