How to fix Error: Socket is not connected (socket must connect before write) in Node.js

Node.jsINTERMEDIATEHIGHUpdated Dec 9, 2025· 204 views

This error occurs when attempting to write data to a Node.js net.Socket before the connection is established. The socket must successfully connect to a remote server before any data can be sent. This typically happens when write() is called immediately without waiting for the "connect" event.

Quick fix

Fixes ERR_SOCKET_NOT_CONNECTED

const net = require('net');

const socket = new net.Socket();

socket.connect(3000, '127.0.0.1', () => {
  // Connection established - safe to write now
  console.log('Socket connected');
  socket.write('Hello from client');
});

socket.on('data', (data) => {
  console.log('Received:', data.toString());
  socket.destroy();
});

socket.on('error', (err) => {
  console.error('Socket error:', err.message);
});

socket.on('close', () => {
  console.log('Socket closed');
});
  1. Wait for the connect event before writing
  2. Use the "connect" event as an alternative
  3. Handle connection errors properly
  4. Implement connection state checking
node.js — error
const net = require('net');
const socket = new net.Socket();
socket.connect(3000, '127.0.0.1', () => {
  // Connection established - safe to write now
  console.log('Socket connected');
  socket.write('Hello from client');
});
socket.on('data', (data) => {
  console.log('Received:', data.toString());
  socket.destroy();
});
socket.on('error', (err) => {
  console.error('Socket error:', err.message);
});
socket.on('close', () => {
  console.log('Socket closed');
});
Error: Socket is not connected (socket must connect before write)

What this error means

In Node.js, a net.Socket is a duplex stream used for TCP network communication. The socket lifecycle has distinct states: initial, connecting, connected, and closed. Writing data to a socket requires an established connection. If you call write() before the socket has successfully connected (not just created), Node.js throws this error because the socket doesn't have an open channel to send data through. This is a common mistake when learning Node.js networking, where developers assume that creating a socket automatically connects it. In reality, you must explicitly call connect() and wait for the "connect" event before writing data.

Typical symptoms

  • Error occurs immediately when trying to send data to a socket
  • Error message: "Error: Socket is not connected"
  • Application crashes when write() is called on a socket
  • WebSocket or TCP communication fails on first message attempt
  • Custom network protocol implementation fails silently or throws error
  • Server stops responding after receiving incomplete or corrupted data

Common causes

  1. Calling socket.write() before waiting for the "connect" event
  2. Socket is not initialized or created properly
  3. Connection failed but code attempts to write anyway
  4. Socket was closed or destroyed before write attempt
  5. Synchronous write() called immediately after socket creation without awaiting connection
  6. Missing error handler leading to failed connection going unnoticed

How to fix "Error: Socket is not connected (socket must connect before write)"

1Wait for the connect event before writing

Always wait for the socket to connect before attempting to write data. Use the "connect" event listener:

javascript
const net = require('net');

const socket = new net.Socket();

socket.connect(3000, '127.0.0.1', () => {
  // Connection established - safe to write now
  console.log('Socket connected');
  socket.write('Hello from client');
});

socket.on('data', (data) => {
  console.log('Received:', data.toString());
  socket.destroy();
});

socket.on('error', (err) => {
  console.error('Socket error:', err.message);
});

socket.on('close', () => {
  console.log('Socket closed');
});

The callback passed to connect() is called when the connection is established.

2Use the "connect" event as an alternative

For more flexibility, listen for the "connect" event separately:

javascript
const net = require('net');

const socket = new net.Socket();

// Set up listeners before connecting
socket.on('connect', () => {
  console.log('Connected to server');
  // Now it's safe to write
  socket.write('Hello server');
});

socket.on('data', (data) => {
  console.log('Response:', data.toString());
});

socket.on('error', (err) => {
  console.error('Socket error:', err.code, err.message);
});

socket.on('close', () => {
  console.log('Connection closed');
});

// Initiate connection
socket.connect(3000, 'localhost');

This pattern gives you more control over error handling and event management.

3Handle connection errors properly

Add error handling to detect connection failures:

javascript
const net = require('net');

const socket = new net.Socket();

socket.on('connect', () => {
  console.log('Connected');
  socket.write('Data');
});

socket.on('error', (err) => {
  // Check specific error codes
  if (err.code === 'ECONNREFUSED') {
    console.error('Connection refused - server not running');
  } else if (err.code === 'ETIMEDOUT') {
    console.error('Connection timeout');
  } else if (err.code === 'ENOTFOUND') {
    console.error('Host not found');
  } else {
    console.error('Connection error:', err.message);
  }
  // Don't attempt to write if connection failed
});

socket.connect(3000, 'localhost');

Never call write() in the error handler or if connection fails.

4Implement connection state checking

Check if the socket is writable before writing:

javascript
const net = require('net');

const socket = new net.Socket();

function safeWrite(data) {
  if (socket.writable && socket.readyState === 'open') {
    socket.write(data);
  } else {
    console.error('Socket not ready for writing');
    console.log('Writable:', socket.writable);
    console.log('Ready state:', socket.readyState);
  }
}

socket.on('connect', () => {
  console.log('Socket connected and ready');
  safeWrite('Hello');
});

socket.on('error', (err) => {
  console.error('Socket error:', err.message);
});

socket.connect(3000, '127.0.0.1');

// This would fail:
// safeWrite('Before connect'); // Not ready yet

Check the writable property to ensure the socket is in a valid state.

5Use promises or async/await for connection

Modernize your approach with promises:

javascript
const net = require('net');

function connectSocket(host, port) {
  return new Promise((resolve, reject) => {
    const socket = new net.Socket();

    socket.on('connect', () => {
      resolve(socket);
    });

    socket.on('error', (err) => {
      reject(err);
    });

    socket.connect(port, host);
  });
}

async function main() {
  try {
    const socket = await connectSocket('localhost', 3000);
    console.log('Connected');

    // Safe to write now
    socket.write('Hello from async client');

    socket.on('data', (data) => {
      console.log('Response:', data.toString());
      socket.destroy();
    });
  } catch (err) {
    console.error('Failed to connect:', err.message);
  }
}

main();

This pattern is cleaner and prevents accidental premature writes.

6Verify server is accepting connections

Before debugging client code, ensure the server is running and listening:

javascript
// Simple echo server for testing
const net = require('net');

const server = net.createServer((socket) => {
  console.log('Client connected');

  socket.on('data', (data) => {
    console.log('Received:', data.toString());
    socket.write('Echo: ' + data.toString());
  });

  socket.on('error', (err) => {
    console.error('Socket error:', err.message);
  });

  socket.on('close', () => {
    console.log('Client disconnected');
  });
});

server.listen(3000, '127.0.0.1', () => {
  console.log('Server listening on port 3000');
});

Run this server in one terminal, then connect clients to it. Test with:

bash
# In another terminal
node client.js

Advanced notes

Socket States in Node.js

A socket has different states accessible via socket.readyState:
- 'opening' - connection in progress
- 'open' - connection established (safe to write)
- 'readOnly' - can't write (half-closed)
- 'writeOnly' - can write but not read (unusual)
- 'closed' - connection closed

Always check socket.writable property to safely determine if writing is allowed.

Handling Half-Open Connections

Sometimes a socket can be in a half-closed state where reading is closed but writing is still possible:

javascript
socket.on('end', () => {
  // Remote end closed the connection
  // You can still write() but shouldn't
  socket.end(); // Gracefully close our end
});

socket.on('close', () => {
  // Both directions closed - no more writes
});

Backpressure and Buffering

If you write large amounts of data, check the return value:

javascript
socket.on('connect', () => {
  const buffer = Buffer.alloc(1024 * 1024); // 1MB
  const canContinue = socket.write(buffer);

  if (!canContinue) {
    console.log('Socket buffer full, waiting for drain');
  }
});

socket.on('drain', () => {
  // Internal buffer has been flushed
  // Safe to write more
  socket.write(moreData);
});

Worker Threads and Socket Sharing

Be careful when sharing sockets across worker threads:

javascript
const { Worker } = require('worker_threads');

// Socket must not be shared between threads
// Instead, communicate via message passing
const worker = new Worker('./worker.js');
worker.on('message', (msg) => {
  if (msg.type === 'write') {
    socket.write(msg.data);
  }
});

TLS/SSL Socket Connection

For secure connections, the same principle applies:

javascript
const tls = require('tls');

const options = {
  host: 'example.com',
  port: 443,
  rejectUnauthorized: false // Only for testing!
};

const socket = tls.connect(options, () => {
  // Connection established and TLS handshake complete
  socket.write('GET / HTTP/1.0\r\nHost: example.com\r\n\r\n');
});

socket.on('data', (data) => {
  console.log(data.toString());
  socket.end();
});

Testing Socket Connections

Use nc (netcat) or telnet to manually test socket servers:

bash
# Test if server is listening
nc -zv localhost 3000

# Interactive connection test
nc localhost 3000
# Type messages and they'll be echoed back

# Or use telnet
telnet localhost 3000

This helps distinguish between code issues and server availability issues.

Frequently asked questions

What does "ERR_SOCKET_NOT_CONNECTED" mean?
Socket is a duplex stream used for TCP network communication. The socket lifecycle has distinct states: initial, connecting, connected, and closed. Writing data to a socket requires an established connection.
How do I fix "ERR_SOCKET_NOT_CONNECTED"?
This error occurs when attempting to write data to a Node.js net.Socket before the connection is established. The socket must successfully connect to a remote server before any data can be sent. This typically happens when write() is called immediately without waiting for the "connect" event.
What causes "ERR_SOCKET_NOT_CONNECTED"?
Calling socket.write() before waiting for the "connect" event Socket is not initialized or created properly Connection failed but code attempts to write anyway
Is the "ERR_SOCKET_NOT_CONNECTED" error serious?
Yes. This is a high-severity error that usually blocks work until it is fixed, but the steps above resolve it.

Official resources & further reading