---
# System prepended metadata

title: Filtering by empty values in Typesense

---

In Typesense, filtering by empty values (i.e., fields that are either null or contain an empty string) directly within a query is not inherently supported. However, you can work around this limitation by pre-processing your data before indexing it in Typesense. Specifically, you can replace empty values with a placeholder value (such as "not specified") during the indexing process. Then, you can filter for this placeholder value in your queries.

Here's a step-by-step guide on how to handle this:

### Step-by-Step Guide

#### Step 1: Pre-process Your Data

Replace empty values in your data with a placeholder value before indexing. Here’s an example in JavaScript:

```javascript
const data = [
  { id: '1', Account_Language: 'en' },
  { id: '2', Account_Language: '' },
  { id: '3', Account_Language: 'fr' },
  { id: '4', Account_Language: '' },
];

// Replace empty values with "not specified"
const processedData = data.map(doc => ({
  ...doc,
  Account_Language: doc.Account_Language || 'not specified'
}));

console.log(processedData);
```

#### Step 2: Index the Processed Data in Typesense

Use the Typesense client to create a collection and index the processed data.

```javascript
import Typesense from 'typesense';

const client = new Typesense.Client({
  nodes: [{
    host: 'localhost',  // For example
    port: '8108',
    protocol: 'http'
  }],
  apiKey: 'xyz',  // Replace with your actual API key
  connectionTimeoutSeconds: 2
});

const collectionSchema = {
  name: 'users',
  fields: [
    { name: 'id', type: 'string' },
    { name: 'Account_Language', type: 'string', facet: true }
  ]
};

async function indexData() {
  try {
    // Check if collection exists, if not create it
    try {
      await client.collections('users').retrieve();
    } catch (error) {
      await client.collections.create(collectionSchema);
    }

    // Index the documents
    await client.collections('users').documents().import(processedData, { action: 'upsert' });

    console.log('Data indexed successfully');
  } catch (error) {
    console.error('Failed to index data', error);
  }
}

indexData();
```

#### Step 3: Query for the Placeholder Value

Now, when you want to filter for empty values, you can query for the placeholder value "not specified".

```javascript
async function search() {
  const searchParameters = {
    q: '*',
    query_by: 'Account_Language',
    filter_by: 'Account_Language:="not specified"',
  };

  try {
    const response = await client.collections('users').documents().search(searchParameters);
    console.log(response);
  } catch (error) {
    console.error('Failed to search data', error);
  }
}

search();
```

### Summary

By pre-processing your data to replace empty values with a placeholder such as "not specified", you enable the ability to filter by these values in your Typesense queries. This approach ensures that all rows with originally empty `Account_Language` fields can be retrieved effectively.