Skip to main content
The Chatter API provides access to Salesforce Chatter REST API endpoints for social collaboration features including feeds, posts, comments, and groups.

​
Overview

The Chatter API supports:
  • Making custom requests to Chatter endpoints
  • CRUD operations on Chatter resources
  • Batch requests for multiple operations
  • Streaming responses

​
Accessing the Chatter API

const conn = new jsforce.Connection({ /* ... */ });
const chatter = conn.chatter;

​
Methods

​
request()

Make a custom request to a Chatter API endpoint.
​
request
ChatterRequestParams
required
Request configuration
​
request.method
string
required
HTTP method (GET, POST, PUT, PATCH, DELETE)
​
request.url
string
required
Chatter endpoint URL (e.g., /feeds/news/me/feed-elements)
​
request.headers
object
Custom HTTP headers
​
request.body
string | object
Request body (automatically JSON-stringified if object)
​
request
Request<S, R>
A Request object that can be executed or batched
// GET request
const feedRequest = conn.chatter.request({
  method: 'GET',
  url: '/feeds/news/me/feed-elements'
});

const feed = await feedRequest;
console.log('Feed items:', feed.elements);

// POST request
const postRequest = conn.chatter.request({
  method: 'POST',
  url: '/feed-elements',
  body: {
    feedElementType: 'FeedItem',
    subjectId: 'me',
    body: {
      messageSegments: [
        {
          type: 'Text',
          text: 'Hello from JSForce!'
        }
      ]
    }
  }
});

const post = await postRequest;
console.log('Created post:', post.id);

​
resource()

Create a Resource object for CRUD operations on a Chatter resource.
​
url
string
required
Resource URL
​
queryParams
object
Query parameters to append to the URL
​
resource
Resource<S, R>
A Resource object with CRUD methods
const userResource = conn.chatter.resource('/users/me');
const user = await userResource.retrieve();
console.log('Current user:', user);

​
batch()

Execute multiple Chatter requests in a single batch operation.
​
requests
Request[]
required
Array of Request objects created via chatter.request()
​
response
BatchResponse
Batch response containing results for all requests
​
response.hasErrors
boolean
Whether any request failed
​
response.results
array
Array of individual request results
​
results[].statusCode
number
HTTP status code
​
results[].result
any
Response data
const req1 = conn.chatter.request({
  method: 'GET',
  url: '/users/me'
});

const req2 = conn.chatter.request({
  method: 'GET',
  url: '/feeds/news/me/feed-elements'
});

const req3 = conn.chatter.request({
  method: 'POST',
  url: '/feed-elements',
  body: {
    feedElementType: 'FeedItem',
    subjectId: 'me',
    body: {
      messageSegments: [{ type: 'Text', text: 'Batch post!' }]
    }
  }
});

const batchResponse = await conn.chatter.batch([req1, req2, req3]);
console.log('Batch results:', batchResponse.results);

// Individual requests are also resolved
const user = await req1;
const feed = await req2;
const post = await req3;

​
Resource Methods

The Resource class provides standard CRUD operations:

​
create()

Create a new resource.
​
data
string | object
required
Resource data to create
const groupResource = conn.chatter.resource('/chatter-groups');
const newGroup = await groupResource.create({
  name: 'Engineering Team',
  information: { text: 'Group for engineering discussions' }
});

​
retrieve()

Retrieve the resource. 
const userResource = conn.chatter.resource('/users/005xx000001X8Uz');
const user = await userResource.retrieve();
console.log('User:', user.name);

​
update()

Update the resource.
​
data
object
required
Updated resource data
const groupResource = conn.chatter.resource('/chatter-groups/0F9xx000000001A');
const updated = await groupResource.update({
  information: { text: 'Updated description' }
});

​
destroy()

Delete the resource. 
const feedElementResource = conn.chatter.resource('/feed-elements/0D5xx000000001A');
await feedElementResource.destroy();
console.log('Feed element deleted');
Aliases: delete(), del()

​
Request Methods

Request objects returned from chatter.request() have these methods:

​
promise()

Get a Promise for the request result. 
const request = conn.chatter.request({
  method: 'GET',
  url: '/users/me'
});

const result = await request.promise();

​
stream()

Get a Node.js stream for the response. 
const request = conn.chatter.request({
  method: 'GET',
  url: '/users/me/photo'
});

const photoStream = request.stream();
photoStream.pipe(fs.createWriteStream('profile.jpg'));

​
then()

Request objects are thenable (Promise-compatible). 
const request = conn.chatter.request({
  method: 'GET',
  url: '/users/me'
});

// Can be used directly with await
const user = await request;

// Or with .then()
request.then(user => {
  console.log('User:', user);
});

​
URL Normalization

The Chatter API automatically normalizes URLs: 
// All of these are equivalent:
conn.chatter.request({ method: 'GET', url: '/feeds/news/me/feed-elements' });
conn.chatter.request({ method: 'GET', url: '/chatter/feeds/news/me/feed-elements' });
conn.chatter.request({ method: 'GET', url: '/services/data/v58.0/chatter/feeds/news/me/feed-elements' });

​
Common Use Cases

​
Post to Chatter Feed

const post = await conn.chatter.request({
  method: 'POST',
  url: '/feed-elements',
  body: {
    feedElementType: 'FeedItem',
    subjectId: 'me', // or a record ID
    body: {
      messageSegments: [
        {
          type: 'Text',
          text: 'Check out this opportunity: '
        },
        {
          type: 'Mention',
          id: '005xx000001X8Uz' // user ID
        },
        {
          type: 'Text',
          text: ' '
        },
        {
          type: 'EntityLink',
          reference: { id: '006xx000001X8Uz' } // opportunity ID
        }
      ]
    }
  }
});

console.log('Posted:', post.id);

​
Get User Feed

const feedResource = conn.chatter.resource('/feeds/news/me/feed-elements', {
  pageSize: 25
});

const feed = await feedResource.retrieve();

for (const element of feed.elements) {
  console.log(`${element.actor.name}: ${element.body.text}`);
}

// Get next page
if (feed.nextPageUrl) {
  const nextPage = conn.chatter.resource(feed.nextPageUrl);
  const moreFeed = await nextPage.retrieve();
}

​
Like a Post

const like = await conn.chatter.request({
  method: 'POST',
  url: `/feed-elements/${feedElementId}/capabilities/chatter-likes/items`
});

​
Comment on a Post

const comment = await conn.chatter.request({
  method: 'POST',
  url: `/feed-elements/${feedElementId}/capabilities/comments/items`,
  body: {
    body: {
      messageSegments: [
        { type: 'Text', text: 'Great post!' }
      ]
    }
  }
});

​
Get Group Members

const members = await conn.chatter.resource(`/chatter-groups/${groupId}/members`).retrieve();
console.log('Members:', members.members);

​
Complete Example

import jsforce from 'jsforce';

const conn = new jsforce.Connection({
  instanceUrl: 'https://yourinstance.salesforce.com',
  accessToken: 'your_access_token'
});

// Get current user
const user = await conn.chatter.resource('/users/me').retrieve();
console.log('Logged in as:', user.name);

// Post to feed
const post = await conn.chatter.request({
  method: 'POST',
  url: '/feed-elements',
  body: {
    feedElementType: 'FeedItem',
    subjectId: 'me',
    body: {
      messageSegments: [
        { type: 'Text', text: 'Hello from JSForce!' }
      ]
    }
  }
});

console.log('Created post:', post.id);

// Get news feed with batch
const feedReq = conn.chatter.request({
  method: 'GET',
  url: '/feeds/news/me/feed-elements'
});

const groupsReq = conn.chatter.request({
  method: 'GET',
  url: '/users/me/groups'
});

const batchResult = await conn.chatter.batch([feedReq, groupsReq]);
console.log('Batch completed:', batchResult.hasErrors ? 'with errors' : 'successfully');

const feed = await feedReq;
const groups = await groupsReq;

console.log(`Found ${feed.elements.length} feed items`);
console.log(`Member of ${groups.groups.length} groups`);
For detailed information about Chatter API endpoints and request formats, see the Salesforce Connect REST API Developer Guide.

​
TypeScript Support

import type { StreamingMessage, BatchResponse } from 'jsforce';

interface FeedElement {
  id: string;
  body: { text: string };
  actor: { name: string };
}

const request = conn.chatter.request<FeedElement>({
  method: 'GET',
  url: '/feed-elements/0D5xx000000001A'
});

const element = await request;
console.log(element.actor.name); // TypeScript knows the shape

Build docs developers (and LLMs) love

Get started for freeTalk to us