siam_fb_api

v1.0.1

Published

2 years ago

A Powerfull Facebook Chat Api :D Made By Siam Rahman.

Downloads

0High
0Medium
0Low

haxorsiam

facebook chat api fca SIAM_FB_API

Documentation

You can use callback or .then() .catch() or async/await

login(credentials, options, [callback]) ⇒ Promise
api.addUserToGroup(userID, threadID, [callback]) ⇒ Promise
api.changeAdminStatus(threadID, adminIDs, adminStatus, [callback]) ⇒ Promise
api.changeArchivedStatus(threadOrThreads, archive, [callback]) ⇒ Promise
api.changeBlockedStatus(userID, block, [callback]) ⇒ Promise
api.changeGroupImage(image, threadID, [callback]) ⇒ Promise
api.changeNickname(nickname, threadID, participantID, [callback]) ⇒ Promise
api.changeThreadColor(color, threadID, [callback]) ⇒ Promise
api.changeThreadEmoji(emoji, threadID, [callback]) ⇒ Promise
api.createNewGroup(participantIDs, groupTitle, [callback]) ⇒ Promise
api.createPoll(title, threadID, options, [callback]) (*temporary deprecated because Facebook is updating this feature*) ⇒ Promise
api.deleteMessage(messageOrMessages, [callback]) ⇒ Promise
api.deleteThread(threadOrThreads, [callback]) ⇒ Promise
api.forwardAttachment(attachmentID, userOrUsers, [callback]) ⇒ Promise
api.getAppState() ⇒ Array
api.getCurrentUserID() ⇒ string
api.getEmojiUrl(c, size, pixelRatio) ⇒ string
api.getFriendsList([callback]) ⇒ Promise
api.getMessage(threadID, messageID, [callback]) ⇒ Promise
api.getThreadHistory(threadID, amount, timestamp, [callback]) ⇒ Promise
api.getThreadInfo(threadIDs, [callback]) ⇒ Promise
api.getThreadList(limit, timestamp, tags, [callback]) ⇒ Promise
api.getThreadPictures(threadID, offset, limit, [callback]) ⇒ Promise
api.getUserID(name, [callback]) ⇒ Promise
api.getUserInfo(ids, [callback]) ⇒ Promise
api.handleMessageRequest(threadID, accept, [callback]) ⇒ Promise
api.httpGet(url, form, [customHeader], [callback], [notAPI]) ⇒ Promise
api.httpPost(url, form, [customHeader], [callback], [notAPI]) ⇒ Promise
api.httpPostFormData(url, form, [customHeader], [callback], [notAPI]) ⇒ Promise
~~api.listen([callback])~~ ⇒ Promise
api.listenMqtt([callback]) ⇒ Promise
api.logout([callback]) ⇒ Promise
api.markAsDelivered(threadID, messageID, [callback] ⇒ Promise
api.markAsRead(threadID, [read, [callback]]) ⇒ Promise
api.markAsReadAll([callback]) ⇒ Promise
api.markAsSeen([seenTimestamp], [callback]) ⇒ Promise
api.muteThread(threadID, muteSeconds, [callback]) ⇒ Promise
api.removeUserFromGroup(userID, threadID, [callback]) ⇒ Promise
api.resolvePhotoUrl(photoID, [callback]) ⇒ Promise
api.searchForThread(name, [callback])
api.sendMessage(message, threadID, [callback], messageID) ⇒ Promise
api.sendTypingIndicator(threadID, [callback]) ⇒ Promise
api.setMessageReaction(reaction, messageID, [callback], [forceCustomReaction]) ⇒ Promise
api.setOptions(options) ⇒ Promise
api.setPostReaction(postID, type, [callback]) ⇒ Promise
api.setTitle(newTitle, threadID, [callback]) ⇒ Promise
api.threadColors ⇒ Object
api.unsendMessage(messageID, [callback]) ⇒ Promise

Password safety

Read this before you copy+paste examples from below.

You should not store Facebook password in your scripts. There are few good reasons:

People who are standing behind you may look at your "code" and get your password if it is on the screen
Backups of source files may be readable by someone else. "There is nothing secret in my code, why should I ever password protect my backups"
You can't push your code to Github (or any onther service) without removing your password from the file. Remember: Even if you undo your accidential commit with password, Git doesn't delete it, that commit is just not used but is still readable by everybody.
If you change your password in the future (maybe it leaked because someone stored password in source file… oh… well…) you will have to change every occurrence in your scripts

Preferred method is to have login.js that saves AppState to a file and then use that file from all your scripts. This way you can put password in your code for a minute, login to facebook and then remove it.

If you want to be even more safe: login.js can get password with require("readline") or with environment variables like this:

var credentials = {
    email: process.env.FB_EMAIL,
    password: process.env.FB_PASSWORD
}

FB_EMAIL="[email protected]"
FB_PASSWORD="MySuperHardP@ssw0rd"
nodejs login.js

login(credentials, options, [callback])

This function is returned by require(...) and is the main entry point to the API.

It allows the user to log into facebook given the right credentials.

Return a Promise that will resolve if logged in successfully, or reject if failed to login. (will not resolve or reject if callback is supplied!)

If callback is supplied:

callback will be called with a null object (for potential errors) and with an object containing all the available functions if logged in successfully.
callback will be called with an error object if failed to login.

If login-approval error was thrown: Inside error object is continue function, you can call that function with 2FA code. The behaviour of this function depends on how you call login with:

If callback is not supplied (using Promise), this function will return a Promise that behaves like Promise received from login.
If callback is supplied, this function will still return a Promise, but it will not resolve. Instead, the result is called to callback.

Arguments

credentials: An object containing the fields email and password used to login, or an object containing the field appState.
options: An object representing options to use when logging in (as described in api.setOptions).
callback(err, api): A callback called when login is done (successful or not). err is an object containing a field error.

Example (Email & Password): (it is no longer usable, please use this alternative method)

const login = require("siam_fb_api");

login({email: "FB_EMAIL", password: "FB_PASSWORD"}, (err, api) => {
    if(err) return console.error(err);
    // Here you can use the api
});

Example (Email & Password then save appState to file): (it is no longer usable, please use this alternative method)

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({email: "FB_EMAIL", password: "FB_PASSWORD"}, (err, api) => {
    if(err) return console.error(err);

    fs.writeFileSync('appstate.json', JSON.stringify(api.getAppState()));
});

Login Approvals (2-Factor Auth): When you try to login with Login Approvals enabled, your callback will be called with an error 'login-approval' that has a continue function that accepts the approval code as a string or a number. (it is no longer usable, please use this alternative method)

Example:

const login = require("siam_fb_api");
const readline = require("readline");

var rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

const obj = {email: "FB_EMAIL", password: "FB_PASSWORD"};
login(obj, (err, api) => {
    if(err) {
        switch (err.error) {
            case 'login-approval':
                console.log('Enter code > ');
                rl.on('line', (line) => {
                    err.continue(line);
                    rl.close();
                });
                break;
            default:
                console.error(err);
        }
        return;
    }

    // Logged in!
});

Review Recent Login: Sometimes Facebook will ask you to review your recent logins. This means you've recently logged in from a unrecognized location. This will will result in the callback being called with an error 'review-recent-login' by default. If you wish to automatically approve all recent logins, you can set the option forceLogin to true in the loginOptions.

Example (AppState loaded from file): You can get fbstate using this extension

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);
    // Here you can use the api
});

api.addUserToGroup(userID, threadID, [callback])

Adds a user (or array of users) to a group chat.

Arguments

userID: User ID or array of user IDs.
threadID: Group chat ID.
callback(err): A callback called when the query is done (either with an error or with no arguments).

api.changeAdminStatus(threadID, adminIDs, adminStatus, [callback])

Given a adminID, or an array of adminIDs, will set the admin status of the user(s) to adminStatus.

Arguments

threadID: ID of a group chat (can't use in one-to-one conversations)
adminIDs: The id(s) of users you wish to admin/unadmin (string or an array).
adminStatus: Boolean indicating whether the user(s) should be promoted to admin (true) or demoted to a regular user (false).
callback(err): A callback called when the query is done (either with an error or null).

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if (err) return console.error(err);

    let threadID = "0000000000000000";
    let newAdmins = ["111111111111111", "222222222222222"];
    api.changeAdminStatus(threadID, newAdmins, true, editAdminsCallback);

    let adminToRemove = "333333333333333";
    api.changeAdminStatus(threadID, adminToRemove, false, editAdminsCallback);

});

function editAdminsCallback(err) {
    if (err) return console.error(err);
}

api.changeArchivedStatus(threadOrThreads, archive, [callback])

Given a threadID, or an array of threadIDs, will set the archive status of the threads to archive. Archiving a thread will hide it from the logged-in user's inbox until the next time a message is sent or received.

Arguments

threadOrThreads: The id(s) of the threads you wish to archive/unarchive.
archive: Boolean indicating the new archive status to assign to the thread(s).
callback(err): A callback called when the query is done (either with an error or null).

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);

    api.changeArchivedStatus("000000000000000", true, (err) => {
        if(err) return console.error(err);
    });
});

api.changeBlockedStatus(userID, block, [callback])

Prevents a user from privately contacting you. (Messages in a group chat will still be seen by both parties).

Arguments

userID: User ID.
block: Boolean indicating whether to block or unblock the user (true for block).
callback(err): A callback called when the query is done (either with an error or with no arguments).

api.changeGroupImage(image, threadID, [callback])

Will change the group chat's image to the given image.

Arguments

image: File stream of image.
threadID: String representing the ID of the thread.
callback(err): A callback called when the change is done (either with an error or null).

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);

    api.changeGroupImage(fs.createReadStream("./avatar.png"), "000000000000000", (err) => {
        if(err) return console.error(err);
    });
});

api.changeNickname(nickname, threadID, participantID, [callback])

Will change the thread user nickname to the one provided.

Arguments

nickname: String containing a nickname. Leave empty to reset nickname.
threadID: String representing the ID of the thread.
participantID: String representing the ID of the user.
callback(err): An optional callback called when the change is done (either with an error or null).

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);

    api.changeNickname("Example", "000000000000000", "000000000000000", (err) => {
        if(err) return console.error(err);
    });
});

api.changeThreadColor(color, threadID, [callback])

Will change the thread color to the given hex string color ("#0000ff"). Set it to empty string if you want the default.

Note: the color needs to start with a "#".

Arguments

color: String representing a theme ID (a list of theme ID can be found at api.threadColors).
threadID: String representing the ID of the thread.
callback(err): A callback called when the change is done (either with an error or null).

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);

    api.changeThreadColor("#0000ff", "000000000000000", (err) => {
        if(err) return console.error(err);
    });
});

api.changeThreadEmoji(emoji, threadID, [callback])

Will change the thread emoji to the one provided.

Note: The UI doesn't play nice with all emoji.

Arguments

emoji: String containing a single emoji character.
threadID: String representing the ID of the thread.
callback(err): A callback called when the change is done (either with an error or null).

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);

    api.changeThreadEmoji("💯", "000000000000000", (err) => {
        if(err) return console.error(err);
    });
});

api.createNewGroup(participantIDs, groupTitle, [callback])

Create a new group chat.

Arguments

participantIDs: An array containing participant IDs. (Length must be >= 2)
groupTitle: The title of the new group chat.
callback(err, threadID): A callback called when created.

api.createPoll(title, threadID, options, [callback]) (temporary deprecated because Facebook is updating this feature)

Creates a poll with the specified title and optional poll options, which can also be initially selected by the logged-in user.

Arguments

title: String containing a title for the poll.
threadID: String representing the ID of the thread.
options: An optional string : bool dictionary to specify initial poll options and their initial states (selected/not selected), respectively.
callback(err): An optional callback called when the poll is posted (either with an error or null) - can omit the options parameter and use this as the third parameter if desired.

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);

    api.createPoll("Example Poll", "000000000000000", {
        "Option 1": false,
        "Option 2": true
    }, (err) => {
        if(err) return console.error(err);
    });
});

api.deleteMessage(messageOrMessages, [callback])

Takes a messageID or an array of messageIDs and deletes the corresponding message.

Arguments

messageOrMessages: A messageID string or messageID string array
callback(err): A callback called when the query is done (either with an error or null).

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);

    api.listen((err, message) => {
        if(message.body) {
            api.sendMessage(message.body, message.threadID, (err, messageInfo) => {
                if(err) return console.error(err);

                api.deleteMessage(messageInfo.messageID);
            });
        }
    });
});

api.deleteThread(threadOrThreads, [callback])

Given a threadID, or an array of threadIDs, will delete the threads from your account. Note that this does not remove the messages from Facebook's servers - anyone who hasn't deleted the thread can still view all of the messages.

Arguments

threadOrThreads - The id(s) of the threads you wish to remove from your account.
callback(err) - A callback called when the operation is done, maybe with an object representing an error.

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);

    api.deleteThread("000000000000000", (err) => {
        if(err) return console.error(err);
    });
});

api.forwardAttachment(attachmentID, userOrUsers, [callback])

Forwards corresponding attachment to given userID or to every user from an array of userIDs

Arguments

attachmentID: The ID field in the attachment object. Recorded audio cannot be forwarded.
userOrUsers: A userID string or usersID string array
callback(err): A callback called when the query is done (either with an error or null).

api.getAppState()

Returns current appState which can be saved to a file or stored in a variable.

api.getCurrentUserID()

Returns the currently logged-in user's Facebook user ID.

api.getEmojiUrl(c, size, pixelRatio)

Returns the URL to a Facebook Messenger-style emoji image asset.

note: This function will return a URL regardless of whether the image at the URL actually exists. This can happen if, for example, Messenger does not have an image asset for the requested emoji.

Arguments

c - The emoji character
size - The width and height of the emoji image; supported sizes are 32, 64, and 128
pixelRatio - The pixel ratio of the emoji image; supported ratios are '1.0' and '1.5' (default is '1.0')

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);

    // Prints https://static.xx.fbcdn.net/images/emoji.php/v8/z9c/1.0/128/1f40d.png
    console.log('Snake emoji, 128px (128x128 with pixel ratio of 1.0');
    console.log(api.getEmojiUrl('\ud83d\udc0d', 128));

    // Prints https://static.xx.fbcdn.net/images/emoji.php/v8/ze1/1.5/128/1f40d.png
    console.log('Snake emoji, 192px (128x128 with pixel ratio of 1.5');
    console.log(api.getEmojiUrl('\ud83d\udc0d', 128, '1.5'));
});

api.getFriendsList([callback])

Returns an array of objects with some information about your friends.

Arguments

callback(err, arr) - A callback called when the query is done (either with an error or with an confirmation object). arr is an array of objects with the following fields: alternateName, firstName, gender, userID, isFriend, fullName, profilePicture, type, profileUrl, vanity, isBirthday.

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);

    api.getFriendsList((err, data) => {
        if(err) return console.error(err);

        console.log(data.length);
    });
});

api.getMessage(threadID, messageID, [callback])

Returns message data from messageID

Arguments

threadID: The ID of the thread you want to get the message from.
messageID: The ID of the message you want to get.
callback(err, data) - A callback called when the query is done.

api.getThreadHistory(threadID, amount, timestamp, [callback])

Takes a threadID, number of messages, a timestamp, and a callback.

note: if you're getting a 500 error, it's possible that you're requesting too many messages. Try reducing that number and see if that works.

Arguments

threadID: A threadID corresponding to the target chat
amount: The amount of messages to request
timestamp: Used to described the time of the most recent message to load. If timestamp is undefined, facebook will load the most recent messages.
callback(error, history): If error is null, history will contain an array of message objects.

Example

To load 50 messages at a time, we can use undefined as the timestamp to retrieve the most recent messages and use the timestamp of the earliest message to load the next 50.

var timestamp = undefined;

function loadNextThreadHistory(api){
    api.getThreadHistory(threadID, 50, timestamp, (err, history) => {
        if(err) return console.error(err);

        /*
            Since the timestamp is from a previous loaded message,
            that message will be included in this history so we can discard it unless it is the first load.
        */
        if(timestamp != undefined) history.pop();

        /*
            Handle message history
        */

        timestamp = history[0].timestamp;
    });
}

api.getThreadInfo(threadIDs, [callback])

Takes a threadID and a callback. Works for both single-user and group threads.

Arguments

threadIDs: Either a string/number for one ID or an array of strings/numbers for a batched query.
callback(err, info): If err is null, info will return

if threadIDs is an array of IDs, info will be an array of objects with the following fields:

{
	"4000000000000000": {
		threadID: "4000000000000000",
		threadName: "Thread Name",
		// ...
		// thread info
	},
	"5000000000000000": {
		threadID: "5000000000000000",
		threadName: "Thread Name",
		// ...
		// thread info
	},
	// ...
}

if threadIDs is a single ID, info will be an object with the following fields:

{
	threadID: "4000000000000000",
	threadName: "Thread Name",
	// ...
	// thread info
}

info will contain the following fields:

| Key | | :---------------: | threadID | | participantIDs | | threadName | | userInfo | | nicknames | | unreadCount | | messageCount | | imageSrc | | timestamp | | muteUntil | | isGroup | | isSubscribed | | folder | | isArchived | | cannotReplyReason | | lastReadTimestamp | | emoji | | color | | adminIDs | | approvalMode | | approvalQueue | inviteLink | Description | | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | ID of the thread | Array of user IDs in the thread | Name of the thread. Usually the name of the user. In group chats, this will be empty if the name of the group chat is unset. | An array contains info of members, which has the same structure as getUserInfo, but add a key id, contain ID of member currently at. | Map of nicknames for members of the thread. If there are no nicknames set, this will be null. Can be of the form: {'123456789': "nickname"} | Number of unread messages | Number of messages | URL to the group chat photo. null if unset or a 1-1 thread. | Timestamp of last activity | Timestamp at which the thread will no longer be muted. The timestamp will be -1 if the thread is muted indefinitely or null if the thread is not muted. | boolean, true if this thread is a group thread (more than 2 participants). | | The folder that the thread is in. Can be one of: INBOX, ARCHIVED, PENDING or OTHER | True if the thread is archived, false if not | If you cannot reply to this thread, this will be a string stating why. Otherwise it will be null. | Timestamp of the last message that is marked as 'read' by the current user. | Object with key 'emoji' whose value is the emoji unicode character. Null if unset. | String form of the custom color in hexadecimal form. | Array of user IDs of the admins of the thread. Empty array if unset. Can be of the form:[{ id: '123456789' }] | true or false, used to check if this group requires admin approval to add users | | Array of object that has the following keys: inviterID: ID of the user invited the person to the grouprequesterID: ID of the person waiting to be approvedtimestamp: Request timestamp | Invite link for the thread. enable: true if the invite link is enabled, false if it is disabled link: Invite link |

accountType is one of the following:

"User"
"Page"
"UnavailableMessagingActor"
"ReducedMessagingActor"

api.getThreadList(limit, timestamp, tags, [callback])

Returns information about the user's threads.

Arguments

limit: Limit the number of threads to fetch.
timestamp: Request threads before this date. null means now
tags: An array describing which folder to fetch. It should be one of these:
- ["INBOX"] (same as [])
- ["ARCHIVED"]
- ["PENDING"]
- ["OTHER"]
- ["INBOX", "unread"]
- ["ARCHIVED", "unread"]
- ["PENDING", "unread"]
- ["OTHER", "unread"]

if you find something new, let us know

callback(err, list): Callback called when the query is done (either with an error or with a proper result). list is an array with objects with the following properties same structure as getThreadInfo

accountType is one of the following:

"User"
"Page"
"UnavailableMessagingActor"
"ReducedMessagingActor"

(there might be more)

In a case that some account type is not supported, we return just this (but you can't rely on it) and log a warning to the console:

| Key | Description | | ----------- | --------------------- | | accountType | type, can be anything | | userID | ID of the account | | name | Name of the account |

api.getThreadPictures(threadID, offset, limit, [callback])

Returns pictures sent in the thread.

Arguments

threadID: A threadID corresponding to the target chat
offset: Start index of picture to retrieve, where 0 is the most recent picture
limit: Number of pictures to get, incrementing from the offset index
callback(err, arr): A callback called when the query is done (either with an error or with an confirmation object). arr is an array of objects with uri, width, and height.

api.getUserID(name, [callback])

Given the full name or vanity name of a Facebook user, event, page, group or app, the call will perform a Facebook Graph search and return all corresponding IDs (order determined by Facebook).

Arguments

name - A string being the name of the item you're looking for.
callback(err, obj) - A callback called when the search is done (either with an error or with the resulting object). obj is an array which contains all of the items that facebook graph search found, ordered by "importance". Each item in the array has the following properties: userID,photoUrl,indexRank, name, isVerified, profileUrl, category, score, type (type is generally user, group, page, event or app).

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);

    api.getUserID("Marc Zuckerbot", (err, data) => {
        if(err) return console.error(err);

        // Send the message to the best match (best by Facebook's criteria)
        var msg = "Hello!"
        var threadID = data[0].userID;
        api.sendMessage(msg, threadID);
    });
});

api.getUserInfo(ids, [callback])

Will get some information about the given users.

Arguments

ids - Either a string/number for one ID or an array of strings/numbers for a batched query.
callback(err, obj) - A callback called when the query is done (either with an error or with an confirmation object). obj is a mapping from userId to another object containing the following properties:

| Key | Description | | ------------- | ------------------------------------------------------------------ | | name | Name of the user | | firstName | First name of the user | | vanity | the username of the user if any | | thumbSrc | URL of the profile picture | | profileUrl | URL of the profile | | gender | the gender of the user, with 1 is Female, 2 is Male, 0 is unknown | | type | type is generally user, group, page, event or app | | isFriend | is the user a friend of the current user, either true or false | | isBirthday | is the user having a birthday today, either true or false | | searchTokens | an array of strings that can be used to search for the user | | alternateName | |

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);

    api.getUserInfo([1, 2, 3, 4], (err, ret) => {
        if(err) return console.error(err);

        for(var prop in ret) {
            if(ret.hasOwnProperty(prop) && ret[prop].isBirthday) {
                api.sendMessage("Happy birthday :)", prop);
            }
        }
    });
});

api.threadColors

A dictionary mapping names of all currently valid thread themes to their theme ID that are accepted by api.changeThreadColor. These themes, listed below, are the ones present in the palette UI used for selecting thread themes on the Messenger client.

MessengerBlue: 196241301102133
Viking: 1928399724138152
GoldenPoppy: 174636906462322
RadicalRed: 2129984390566328
Shocking: 2058653964378557
FreeSpeechGreen: 2136751179887052
Pumpkin: 175615189761153
LightCoral: 980963458735625
MediumSlateBlue: 234137870477637
DeepSkyBlue: 2442142322678320
BrilliantRose: 169463077092846
DefaultBlue: 196241301102133
HotPink: 169463077092846
AquaBlue: 2442142322678320
BrightPurple: 234137870477637
CoralPink: 980963458735625
Orange: 175615189761153
Green: 2136751179887052
LavenderPurple: 2058653964378557
Red: 2129984390566328
Yellow: 174636906462322
TealBlue: 1928399724138152
Aqua: 417639218648241
Mango: 930060997172551
Berry: 164535220883264
Citrus: 370940413392601
Candy: 205488546921017
Earth: 1833559466821043
Support: 365557122117011
Music: 339021464972092
Pride: 1652456634878319
DoctorStrange: 538280997628317
LoFi: 1060619084701625
Sky: 3190514984517598
LunarNewYear: 357833546030778
Celebration: 627144732056021
Chill: 390127158985345
StrangerThings: 1059859811490132
Dune: 1455149831518874
Care: 275041734441112
Astrology: 3082966625307060
JBalvin: 184305226956268
Birthday: 621630955405500
Cottagecore: 539927563794799
Ocean: 736591620215564
Love: 741311439775765
TieDye: 230032715012014
Monochrome: 788274591712841
Default: 3259963564026002
Rocket: 582065306070020
Berry2: 724096885023603
Candy2: 624266884847972
Unicorn: 273728810607574
Tropical: 262191918210707
Maple: 2533652183614000
Sushi: 909695489504566
Citrus2: 557344741607350
Lollipop: 280333826736184
Shadow: 271607034185782
Rose: 1257453361255152
Lavender: 571193503540759
Tulip: 2873642949430623
Classic: 3273938616164733
Peach: 3022526817824329
Honey: 672058580051520
Kiwi: 3151463484918004
Grape: 193497045377796
NonBinary: 737761000603635
~~StarWars: 809305022860427~~ (Facebook removed it.)

api.handleMessageRequest(threadID, accept, [callback])

Accept or ignore message request(s) with thread id threadID.

Arguments

threadID: A threadID or array of threadIDs corresponding to the target thread(s). Can be numbers or strings.
accept: Boolean indicating the new status to assign to the message request(s); true for inbox, false to others.
callback(err): A callback called when the query is done (with an error or with null).

api.httpGet(url, form, [customHeader], [callback], [notAPI])

Get data from a URL with method GET.

Arguments

url: A string being the URL to get data from.
form: An object containing the form data to send.
customHeader: An object containing custom headers to send.
callback(err, data): A callback called when the query is done (either with an error or with the resulting data).
notAPI: A boolean indicating whether the request is made from the API or not (default: false, meaning it's from the API).

api.httpPost(url, form, [customHeader], [callback], [notAPI])

Get data from a URL with method POST.

Arguments

Similar to api.httpGet.

api.httpPostFormData(url, form, [customHeader], [callback], [notAPI])

Post form data to a URL.

Arguments

Similar to api.httpGet.

api.listen([callback])

api.listenMqtt([callback])

Will call callback when a new message is received on this account. By default this won't receive events (joining/leaving a chat, title change etc...) but it can be activated with api.setOptions({listenEvents: true}). This will by default ignore messages sent by the current account, you can enable listening to your own messages with api.setOptions({selfListen: true}). This returns an EventEmitter that contains function stopListening that will stop the listen loop and is guaranteed to prevent any future calls to the callback given to listen. An immediate call to stopListening when an error occurs will prevent the listen function to continue.

If callback is not defined, or isn't a Function, you can listen to messages with event message and error from EventEmitter returned by this function.

Arguments

callback(error, message): A callback called every time the logged-in account receives a new message.

Message

The message object will contain different fields based on its type (as determined by its type field). By default, the only type that will be listened for is message. If enabled through setOptions, the message object may alternatively represent an event e.g. a read receipt. The available event types are as follows:

Attachments

Similar to how messages can vary based on their type, so too can the attachments within "message" events. Each attachment will consist of an object of one of the following types:

| Attachment Type | Fields | | ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------- | | "sticker" | ID, url, packID, spriteUrl, spriteUrl2x, width, height, caption, description, frameCount, frameRate, framesPerRow, framesPerCol | | "file" | ID, filename, url, isMalicious, contentType | | "photo" | ID, filename, thumbnailUrl, previewUrl, previewWidth, previewHeight, largePreviewUrl, largePreviewWidth, largePreviewHeight | | "animated_image" | ID, filename, previewUrl, previewWidth, previewHeight, url, width, height | | "video" | ID, filename, previewUrl, previewWidth, previewHeight, url, width, height, duration, videoType | | "audio" | ID, filename, audioType, duration, url, isVoiceMail | | "location" | ID, latitude, longitude, image, width, height, url, address | | "share" | ID, url, title, description, source, image, width, height, playable, duration, playableUrl, subattachments, properties |

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

// Simple echo bot. He'll repeat anything that you say.
// Will stop when you say '/stop'

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);

    api.setOptions({listenEvents: true});

    var listenEmitter = api.listen((err, event) => {
        if(err) return console.error(err);

        switch (event.type) {
            case "message":
                if(event.body === '/stop') {
                    api.sendMessage("Goodbye...", event.threadID);
                    return listenEmitter.stopListening();
                }
                api.markAsRead(event.threadID, (err) => {
                    if(err) console.log(err);
                });
                api.sendMessage("TEST BOT: " + event.body, event.threadID);
                break;
            case "event":
                console.log(event);
                break;
        }
    });
});

api.logout([callback])

Logs out the current user.

Arguments

callback(err): A callback called when the query is done (either with an error or with null).

api.markAsDelivered(threadID, messageID, [callback]])

Given a threadID and a messageID will mark that message as delivered. If a message is marked as delivered that tells facebook servers that it was recieved.

You can also mark new messages as delivered automatically. This is enabled by default. See api.setOptions.

Arguments

threadID - The id of the thread in which you want to mark the message as delivered.
messageID - The id of the message want to mark as delivered.
callback(err) - A callback called when the operation is done maybe with an object representing an error.

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);

    api.listen((err, message) => {
        if(err) return console.error(err);

        // Marks messages as delivered immediately after they're received
        api.markAsDelivered(message.threadID, message.messageID);
    });
});

api.markAsRead(threadID, [read, [callback]])

Given a threadID will mark all the unread messages in a thread as read. Facebook will take a couple of seconds to show that you've read the messages.

You can also mark new messages as read automatically. See api.setOptions. But be careful, this will make your account getting banned, especially when receiving HUGE amount of messages.

Arguments

threadID - The id of the thread in which you want to mark the messages as read.
read - An optional boolean where true means to mark the message as being "read" and false means to mark the message as being "unread".
callback(err) - A callback called when the operation is done maybe with an object representing an error.

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);

    api.listen((err, message) => {
        if(err) return console.error(err);

        // Marks messages as read immediately after they're received
        api.markAsRead(message.threadID);
    });
});

api.markAsReadAll([callback])

This function will mark all of messages in your inbox readed.

api.markAsSeen([seenTimestamp], [callback])

This function will mark your entire inbox as seen (don't be confused with read!).

api.muteThread(threadID, muteSeconds, [callback])

Mute a chat for a period of time, or unmute a chat.

Arguments

threadID - The ID of the chat you want to mute.
muteSeconds - Mute the chat for this amount of seconds. Use 0 to unmute a chat. Use '-1' to mute a chat indefinitely.
callback(err) - A callback called when the operation is done maybe with an object representing an error.

Example

const fs = require("fs-extra");
const login = require("siam_fb_api");

login({appState: JSON.parse(fs.readFileSync('appstate.json', 'utf8'))}, (err, api) => {
    if(err) return console.error(err);

    api.listen((err, message) => {
        if(err) return console.error(err);

        // Mute all incoming chats for one minute
        api.muteThread(message.threadID, 60);
    });
});

api.removeUserFromGroup(userID, threadID, [callback])

Removes a user from a group chat.

Arguments

userID: User ID.
threadID: Group chat ID.
callback(err): A callback called when the query is done (either with an error or with no arguments).

api.resolvePhotoUrl(photoID, [callback])

Resolves the URL to the full-size photo, given its ID. This function is useful for retrieving the full-size photo URL of image attachments in messages, returned by api.getThreadHistory.

Arguments

photoID: Photo ID.
callback(err, url): A callback called when the query is done (either with an error or with the photo's URL). url is a string with the photo's URL.

api.searchForThread(name, [callback])

This part is outdated. see #396

Takes a chat title (thread name) and returns matching results as a formatted threads array (ordered according to Facebook).

Arguments

name: A messageID string or messageID string array
callback(err, obj): A callback called when the query is done (either with an error or a thread object). The object passed in the callback has the following shape: threadID, participants, participantIDs, formerParticipants, name, nicknames, snippet, snippetHasAttachment, snippetAttachments, snippetSender, unreadCount, messageCount, imageSrc, timestamp, serverTimestamp, muteSettings, isCanonicalUser, isCanonical, canonicalFbid, isSubscribed, rootMessageThreadingID, folder, isArchived, recipientsLoadable, hasEmailParticipant, readOnly, canReply, composerEnabled, blockedParticipants, lastMessageID

api.sendMessage(message, threadID, [callback], messageID)

Sends the given message to the threadID.

Arguments

message: A string (for backward compatibility) or a message object as described below.
threadID: A string, number, or array representing a thread. It happens to be someone's userID in the case of a one to one conversation or an array of userIDs when starting a new group chat.
callback(err, messageInfo): (Optional) A callback called when sending the message is done (either with an error or with an confirmation object). messageInfo contains the threadID where the message was sent and a messageID, as well as the timestamp of the message.
messageID: (Optional) A string representing a message you want to reply.

Message Object:

Various types of message can be sent:

Regular: set field body to the desired message as a string.
Sticker: set a field sticker to the desired sticker ID.
File or image: Set field attachment to a readable stream or an array of readable streams.
URL: set a field url to the desired URL.
Emoji: set field emoji to the desired emoji as a string and set field emojiSize with size of the emoji (small, medium, large)
Mentions: set fie

Published

Vulnerabilities

Links

Maintainers

Keywords

Readme

Documentation

You can use callback or .then() .catch() or async/await

Password safety

login(credentials, options, [callback])

Example (AppState loaded from file): You can get fbstate using this extension

api.addUserToGroup(userID, threadID, [callback])

api.changeAdminStatus(threadID, adminIDs, adminStatus, [callback])

api.changeArchivedStatus(threadOrThreads, archive, [callback])

api.changeBlockedStatus(userID, block, [callback])

api.changeGroupImage(image, threadID, [callback])

api.changeNickname(nickname, threadID, participantID, [callback])

api.changeThreadColor(color, threadID, [callback])

api.changeThreadEmoji(emoji, threadID, [callback])

api.createNewGroup(participantIDs, groupTitle, [callback])

api.createPoll(title, threadID, options, [callback]) (temporary deprecated because Facebook is updating this feature)

api.deleteMessage(messageOrMessages, [callback])

api.deleteThread(threadOrThreads, [callback])

api.forwardAttachment(attachmentID, userOrUsers, [callback])

api.getAppState()

api.getCurrentUserID()

api.getEmojiUrl(c, size, pixelRatio)

api.getFriendsList([callback])

api.getMessage(threadID, messageID, [callback])

api.getThreadHistory(threadID, amount, timestamp, [callback])

api.getThreadInfo(threadIDs, [callback])

api.getThreadList(limit, timestamp, tags, [callback])

api.getThreadPictures(threadID, offset, limit, [callback])

api.getUserID(name, [callback])

api.getUserInfo(ids, [callback])

api.threadColors

api.handleMessageRequest(threadID, accept, [callback])

api.httpGet(url, form, [customHeader], [callback], [notAPI])

api.httpPost(url, form, [customHeader], [callback], [notAPI])

api.httpPostFormData(url, form, [customHeader], [callback], [notAPI])

~~api.listen([callback])~~

api.listenMqtt([callback])

api.logout([callback])

api.markAsDelivered(threadID, messageID, [callback]])

api.markAsRead(threadID, [read, [callback]])

api.markAsReadAll([callback])

api.markAsSeen([seenTimestamp], [callback])

api.muteThread(threadID, muteSeconds, [callback])

api.removeUserFromGroup(userID, threadID, [callback])

api.resolvePhotoUrl(photoID, [callback])

api.searchForThread(name, [callback])

api.sendMessage(message, threadID, [callback], messageID)

api.listen([callback])