MessengerClient | messaging-apis

Hierarchy

MessengerClient

Index

Constructors

constructor

Properties

Methods

Constructors

constructor

new MessengerClient(config: ClientConfig): MessengerClient

- Defined in messaging-api-messenger/src/MessengerClient.ts:97
Parameters
- config: ClientConfig
Returns MessengerClient

Properties

Readonly accessToken

accessToken: string

The access token used by the client.

Optional Readonly appId

appId?: string

The app ID used by the client.

Optional Readonly appSecret

appSecret?: string

The app secret used by the client.

Readonly axios

axios: AxiosInstance

The underlying axios instance.

Readonly version

version: string

The version of the Facebook Graph API.

Methods

associateLabel

associateLabel(userId: string, labelId: number): Promise<{ success: true }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2402
Associates a label to a specific PSID
see
https://developers.facebook.com/docs/messenger-platform/identity/custom-labels#associate_label

example
```
await client.associateLabel(USER_ID, LABEL_ID);
```
Parameters
- userId: string
  Facebook page-scoped user ID of the user
- labelId: number
  ID of the custom label
Returns Promise<{ success: true }>
Success status

createLabel

createLabel(name: string): Promise<{ id: string }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2376
Creates a label
see
https://developers.facebook.com/docs/messenger-platform/identity/custom-labels#create_label

example
```
await client.createLabel('awesome');
// {
//   id: 1712444532121303
// }
```
Parameters
- name: string
  Name of the custom label
Returns Promise<{ id: string }>
An object includes label ID.

createPersona

createPersona(persona: Persona): Promise<{ id: string }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:3583
Creates a Persona.
see
https://developers.facebook.com/docs/messenger-platform/send-messages/personas/#create

example
```
await client.createPersona({
  name: 'John Mathew',
  profilePictureUrl: 'https://facebook.com/john_image.jpg',
});
// {
//   "id": "<PERSONA_ID>"
// }
```
Parameters
- persona: Persona
  Data of the new persona
Returns Promise<{ id: string }>
- ID of the persona

createSubscription

createSubscription(__namedParameters: { accessToken: string; callbackUrl: string; fields?: string[]; includeValues?: boolean; object?: "user" | "page" | "permissions" | "payments"; verifyToken: string }): Promise<{ success: boolean }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:321
Create new Webhooks subscriptions.
see
https://developers.facebook.com/docs/graph-api/reference/app/subscriptions

example
```
await client.createSubscription({
  accessToken: APP_ACCESS_TOKEN,
  callbackUrl: 'https://mycallback.com',
  fields: ['messages', 'messaging_postbacks', 'messaging_referrals'],
  verifyToken: VERIFY_TOKEN,
});

// Or provide app id and app secret instead of app access token:
client.createSubscription({
  accessToken: `${APP_ID}|${APP_SECRET}`,
  callbackUrl: 'https://mycallback.com',
  fields: ['messages', 'messaging_postbacks', 'messaging_referrals'],
  verifyToken: VERIFY_TOKEN,
});
```
Parameters
- __namedParameters: { accessToken: string; callbackUrl: string; fields?: string[]; includeValues?: boolean; object?: "user" | "page" | "permissions" | "payments"; verifyToken: string }
  - accessToken: string
  - callbackUrl: string
  - Optional fields?: string[]
  - Optional includeValues?: boolean
  - Optional object?: "user" | "page" | "permissions" | "payments"
  - verifyToken: string
Returns Promise<{ success: boolean }>
Success status

debugToken

debugToken(): Promise<TokenInfo>

Gets token information.

see

https://developers.facebook.com/docs/facebook-login/access-tokens/debugging-and-error-handling

example

await client.debugToken();
// {
//   appId: '000000000000000',
//   application: 'Social Cafe',
//   expiresAt: 1352419328,
//   isValid: true,
//   issuedAt: 1347235328,
//   scopes: ['email', 'user_location'],
//   userId: 1207059,
// }

Returns Promise<TokenInfo>

Token information

deleteAccountLinkingURL

deleteAccountLinkingURL(): Promise<MutationSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1190
Deletes account linking URL.
see
https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api/account-linking-url

example
```
await client.deleteAccountLinkingURL();
```
Returns Promise<MutationSuccessResponse>
Success status

deleteGetStarted

deleteGetStarted(): Promise<MutationSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:702
Deletes get started button.
see
https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api/get-started-button

example
```
await client.deleteGetStarted();
```
Returns Promise<MutationSuccessResponse>
Success status

deleteGreeting

deleteGreeting(): Promise<MutationSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:997
Deletes greeting text.
see
https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api/greeting

example
```
await client.deleteGreeting();
```
Returns Promise<MutationSuccessResponse>
Success status

deleteIceBreakers

deleteIceBreakers(): Promise<MutationSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1070
Deletes ice breakers.
example
```
await client.deleteIceBreakers();
```
Returns Promise<MutationSuccessResponse>
Success status

deleteLabel

deleteLabel(labelId: number): Promise<{ success: true }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2602
Deletes a Label.
see
https://developers.facebook.com/docs/messenger-platform/identity/custom-labels#delete_label

example
```
await client.deleteLabel(LABEL_ID);
```
Parameters
- labelId: number
  ID of the custom label to delete.
Returns Promise<{ success: true }>
Success status

deleteMessengerProfile

deleteMessengerProfile(fields: string[]): Promise<MutationSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:622
Deletes one or more Messenger Profile properties. Only properties specified in the fields array will be deleted.
see
https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api#delete

example
```
await client.deleteMessengerProfile(['get_started', 'persistent_menu']);
```
Parameters
- fields: string[]
  An array of Messenger profile properties to delete. Value must be among account_linking_url, persistent_menu, get_started, greeting, ice_breakers and whitelisted_domains.
Returns Promise<MutationSuccessResponse>
Success status

deletePersistentMenu

deletePersistentMenu(): Promise<MutationSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:824
Deletes persistent menu.
see
https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api/persistent-menu

example
```
await client.deletePersistentMenu();
```
Returns Promise<MutationSuccessResponse>

deletePersona

deletePersona(personaId: string): Promise<{ success: true }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:3755
Deletes a persona.
see
https://developers.facebook.com/docs/messenger-platform/send-messages/personas/#remove

example
```
await client.deletePersona('PERSONA_ID');
```
Parameters
- personaId: string
  ID of the persona.
Returns Promise<{ success: true }>
Success status.

deleteUserPersistentMenu

deleteUserPersistentMenu(userId: string): Promise<MutationSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:911
example
Parameters
- userId: string
Returns Promise<MutationSuccessResponse>

deleteWhitelistedDomains

deleteWhitelistedDomains(): Promise<MutationSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1129
Deletes whitelisted domains.
see
https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api/domain-whitelisting

example
```
await client.deleteWhitelistedDomains();
```
Returns Promise<MutationSuccessResponse>
Success status

disableNLP

disableNLP(): Promise<any>

- Defined in messaging-api-messenger/src/MessengerClient.ts:3299
Disables Built-in NLP.
see
https://developers.facebook.com/docs/messenger-platform/built-in-nlp

example
```
await client.disableNLP();
```
Returns Promise<any>

dissociateLabel

dissociateLabel(userId: string, labelId: number): Promise<{ success: true }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2428
Removes a label currently associated with a PSID
see
https://developers.facebook.com/docs/messenger-platform/identity/custom-labels#remove_label

example
```
await client.dissociateLabel(USER_ID, LABEL_ID);
```
Parameters
- userId: string
  Facebook page-scoped user ID of the user
- labelId: number
  ID of the custom label
Returns Promise<{ success: true }>
Success status

enableNLP

enableNLP(): Promise<any>

- Defined in messaging-api-messenger/src/MessengerClient.ts:3281
Enables Built-in NLP.
see
https://developers.facebook.com/docs/messenger-platform/built-in-nlp

example
```
await client.enableNLP();
```
Returns Promise<any>

getAccountLinkingURL

getAccountLinkingURL(): Promise<null | string>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1147
Retrieves the current value of account linking URL.
see
https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api/account-linking-url

example
```
await client.getAccountLinkingURL();
// 'https://www.example.com/oauth?response_type=code&client_id=1234567890&scope=basic'
```
Returns Promise<null | string>
Account linking URL

getAllPersonas

getAllPersonas(): Promise<{ id: string; name: string; profilePictureUrl: string }[]>

Retrieves all personas associated with a page.

example

await client.getAllPersonas();
// [
//   {
//     "name": "John Mathew",
//     "profile_picture_url": "https://facebook.com/john_image.jpg",
//     "id": "<PERSONA_ID>"
//   },
//   {
//     "name": "David Mark",
//     "profile_picture_url": "https://facebook.com/david_image.jpg",
//     "id": "<PERSONA_ID>"
//   }
// ]

Returns Promise<{ id: string; name: string; profilePictureUrl: string }[]>

an array of all personas

getAssociatedLabels

getAssociatedLabels(userId: string, options?: { fields?: string[] }): Promise<{ data: { id: string; name: string }[]; paging: { cursors: { after: string; before: string } } }>

Retrieves the labels currently associated with a PSID

see

https://developers.facebook.com/docs/messenger-platform/identity/custom-labels#retrieving_labels_by_psid

example

await client.getAssociatedLabels(USER_ID);
// {
//   data: [
//     {
//       name: 'myLabel',
//       id: '1001200005003',
//     },
//     {
//       name: 'myOtherLabel',
//       id: '1001200005002',
//     },
//   ],
//   paging: {
//     cursors: {
//       before:
//         'QVFIUmx1WTBpMGpJWXprYzVYaVhabW55dVpycko4U2xURGE5ODNtNFZAPal94a1hTUnNVMUtoMVVoTzlzSDktUkMtQkUzWEFLSXlMS3ZALYUw3TURLelZAPOGVR',
//       after:
//         'QVFIUmItNkpTbjVzakxFWGRydzdaVUFNNnNPaUl0SmwzVHN5ZAWZAEQ3lZANDAzTXFIM0NHbHdYSkQ5OG1GaEozdjkzRmxpUFhxTDl4ZAlBibnE4LWt1eGlTa3Bn',
//     },
//   },
// }

Parameters

userId: string
Facebook page-scoped user ID of the user
options: { fields?: string[] } = {}
- Optional fields?: string[]

Returns Promise<{ data: { id: string; name: string }[]; paging: { cursors: { after: string; before: string } } }>

Associated labels in pagination result

getBlockedConversations

getBlockedConversations(options: InsightOptions): Promise<{ name: "page_messages_blocked_conversations_unique"; period: "day"; values: { endTime: string; value: number | object }[] }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:3091
Retrieves the number of conversations with the Page that have been blocked.
see
https://developers.facebook.com/docs/messenger-platform/reference/messaging-insights-api#metrics

example
```
await client.getBlockedConversations();
// {
//   "name": "page_messages_blocked_conversations_unique",
//   "period": "day",
//   "values": [
//     {
//       "value": "<VALUE>",
//       "endTime": "<UTC_TIMESTAMP>"
//     },
//     {
//       "value": "<VALUE>",
//       "endTime": "<UTC_TIMESTAMP>"
//     }
//  ]
// }
```
Parameters
- options: InsightOptions
  Optional arguments.
Returns Promise<{ name: "page_messages_blocked_conversations_unique"; period: "day"; values: { endTime: string; value: number | object }[] }>

getGetStarted

getGetStarted(): Promise<null | { payload: string }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:653
Retrieves the current value of get started button.
see
https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api/get-started-button

example
```
await client.getGetStarted();
// {
//   payload: 'GET_STARTED',
// }
```
Returns Promise<null | { payload: string }>
Config of get started button

getGreeting

getGreeting(): Promise<null | GreetingConfig[]>

- Defined in messaging-api-messenger/src/MessengerClient.ts:940
Retrieves the current value of greeting text.
see
https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api/greeting

example
```
await client.getGreeting();
// [
//   {
//     locale: 'default',
//     text: 'Hello!',
//   },
// ]
```
Returns Promise<null | GreetingConfig[]>
Array of greeting configs

getIceBreakers

getIceBreakers(): Promise<null | IceBreaker[]>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1024
Retrieves the current value of ice breakers.
see
https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api/ice-breakers

example
```
await client.getIceBreakers()
// [
//   {
//     "question": "<QUESTION>",
//     "payload": "<PAYLOAD>",
//   },
//   {
//     "question": "<QUESTION>",
//     "payload": "<PAYLOAD>",
//   }
// ]
```
Returns Promise<null | IceBreaker[]>
Array of ice breakers.

getIdsForApps

getIdsForApps(__namedParameters: { app?: string; appSecret: string; page?: string; userId: string }): Promise<{ data: { app: { category?: string; id: string; link: string; name: string; namespace?: string }; id: string }[]; paging: { cursors: { after: string; before: string } } }>

Given a user ID for a bot in Messenger, retrieve the IDs for apps owned by the same business

see

https://developers.facebook.com/docs/messenger-platform/identity/id-matching

example

await client.getIdsForApps({
  userId: USER_ID,
  appSecret: APP_SECRET,
});
// {
//   data: [
//     {
//       id: '10152368852405295',
//       app: {
//         category: 'Business',
//         link: 'https://www.facebook.com/games/?app_id=1419232575008550',
//         name: "John's Game App",
//         id: '1419232575008550',
//       },
//     },
//     {
//       id: '645195294',
//       app: {
//         link: 'https://apps.facebook.com/johnsmovieappns/',
//         name: 'JohnsMovieApp',
//         namespace: 'johnsmovieappns',
//         id: '259773517400382',
//       },
//     },
//   ],
//   paging: {
//     cursors: {
//       before: 'MTQ4OTU4MjQ5Nzc4NjY4OAZDZDA',
//       after: 'NDAwMDExOTA3MDM1ODMwA',
//     },
//   },
// };

Parameters

__namedParameters: { app?: string; appSecret: string; page?: string; userId: string }
- Optional app?: string
- appSecret: string
- Optional page?: string
- userId: string

Returns Promise<{ data: { app: { category?: string; id: string; link: string; name: string; namespace?: string }; id: string }[]; paging: { cursors: { after: string; before: string } } }>

User IDs in pagination result

getIdsForPages

getIdsForPages(__namedParameters: { app?: string; appSecret: string; page?: string; userId: string }): Promise<{ data: { id: string; page: { category?: string; id: string; link: string; name: string; namespace?: string } }[]; paging: { cursors: { after: string; before: string } } }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:3518
Given a user ID for a Page (associated with a bot), retrieve the IDs for other Pages owned by the same business
see
https://developers.facebook.com/docs/messenger-platform/identity/id-matching

example
```
await client.getIdsForPages({
  userId: USER_ID,
  appSecret: APP_SECRET,
});
// {
//   data: [
//     {
//       id: '12345123', // The psid for the user for that page
//       page: {
//         category: 'Musician',
//         link:
//           'https://www.facebook.com/Johns-Next-Great-Thing-380374449010653/',
//         name: "John's Next Great Thing",
//         id: '380374449010653',
//       },
//     },
//   ],
//   paging: {
//     cursors: {
//       before: 'MTQ4OTU4MjQ5Nzc4NjY4OAZDZDA',
//       after: 'NDAwMDExOTA3MDM1ODMwA',
//     },
//   },
// };
```
Parameters
- __namedParameters: { app?: string; appSecret: string; page?: string; userId: string }
  - Optional app?: string
  - appSecret: string
  - Optional page?: string
  - userId: string
Returns Promise<{ data: { id: string; page: { category?: string; id: string; link: string; name: string; namespace?: string } }[]; paging: { cursors: { after: string; before: string } } }>
User IDs in pagination result

getInsights

getInsights(metrics: InsightMetric[], options?: InsightOptions): Promise<any>

Retrieves the insights of your Facebook page.

see

https://developers.facebook.com/docs/messenger-platform/reference/messaging-insights-api

example

await client.getInsights(['page_messages_reported_conversations_unique']);
// [
//   {
//     "name": "page_messages_reported_conversations_unique",
//     "period": "day",
//     "values": [
//       {
//         "value": "<VALUE>",
//         "endTime": "<UTC_TIMESTAMP>"
//       },
//       {
//         "value": "<VALUE>",
//         "endTime": "<UTC_TIMESTAMP>"
//       }
//     ]
//   }
// ]

Parameters

metrics: InsightMetric[]
The metrics you want to check.
options: InsightOptions = {}
Optional arguments.

Returns Promise<any>

getLabelDetails

getLabelDetails(labelId: number, options?: { fields?: string[] }): Promise<{ id: string; name: string }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2520
Retrieves details of the label
see
https://developers.facebook.com/docs/messenger-platform/identity/custom-labels#get_label_details

example
```
await client.getLabelDetails(LABEL_ID, { fields: ['name'] });
// {
//   id: "1001200005002",
//   name: "myLabel",
// }
```
Parameters
- labelId: number
  ID of the custom label
- options: { fields?: string[] } = {}
  Other optional parameters.
  - Optional fields?: string[]
    Fields to retrieve with its ID.
Returns Promise<{ id: string; name: string }>

getLabelList

getLabelList(options?: { fields?: string[] }): Promise<{ data: { id: string; name: string }[]; paging: { cursors: { after: string; before: string } } }>

Retrieves a list of custom labels

see

https://developers.facebook.com/docs/messenger-platform/identity/custom-labels#get_all_labels

example

await client.getLabelList();
// {
//   data: [
//     {
//       name: 'myLabel',
//       id: '1001200005003',
//     },
//     {
//       name: 'myOtherLabel',
//       id: '1001200005002',
//     },
//   ],
//   paging: {
//     cursors: {
//       before:
//         'QVFIUmx1WTBpMGpJWXprYzVYaVhabW55dVpycko4U2xURGE5ODNtNFZAPal94a1hTUnNVMUtoMVVoTzlzSDktUkMtQkUzWEFLSXlMS3ZALYUw3TURLelZAPOGVR',
//       after:
//         'QVFIUmItNkpTbjVzakxFWGRydzdaVUFNNnNPaUl0SmwzVHN5ZAWZAEQ3lZANDAzTXFIM0NHbHdYSkQ5OG1GaEozdjkzRmxpUFhxTDl4ZAlBibnE4LWt1eGlTa3Bn',
//     },
//   },
// }

Parameters

options: { fields?: string[] } = {}
- Optional fields?: string[]

Returns Promise<{ data: { id: string; name: string }[]; paging: { cursors: { after: string; before: string } } }>

Custom labels in pagination result

getMessagingFeatureReview

getMessagingFeatureReview(): Promise<MessagingFeatureReview[]>

- Defined in messaging-api-messenger/src/MessengerClient.ts:473
Programmatically check the feature submission status of page-level platform features
see
https://developers.facebook.com/docs/messenger-platform/reference/messaging-feature-review-api

example
```
await client.getMessagingFeatureReview();
// [{
//   "feature": "subscription_messaging",
//   "status": "<pending|rejected|approved|limited>"
// }]
```
Returns Promise<MessagingFeatureReview[]>
An array of all submitted feature submission requests. If no request has been submitted, the array will be empty.

getMessengerProfile

getMessengerProfile(fields: string[]): Promise<MessengerProfile[]>

- Defined in messaging-api-messenger/src/MessengerClient.ts:554
Retrieves the current value of one or more Messenger Profile properties by name.
see
https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api

example
```
await client.getMessengerProfile(['get_started', 'persistent_menu']);
// [
//   {
//     getStarted: {
//       payload: 'GET_STARTED',
//     },
//   },
//   {
//     persistentMenu: [
//       {
//         locale: 'default',
//         composerInputDisabled: true,
//         callToActions: [
//           {
//             type: 'postback',
//             title: 'Restart Conversation',
//             payload: 'RESTART',
//           },
//         ],
//       },
//     ],
//   },
// ]
```
Parameters
- fields: string[]
  An array of Messenger profile properties to retrieve. Value must be among account_linking_url, persistent_menu, get_started, greeting, ice_breakers and whitelisted_domains.
Returns Promise<MessengerProfile[]>
The current value of the requested properties

getNewConversations

getNewConversations(options: InsightOptions): Promise<{ name: "page_messages_new_conversations_unique"; period: "day"; values: { endTime: string; value: number | object }[] }>

Retrieves the number of messaging conversations on Facebook Messenger that began with people who had never messaged with your business before.

see

https://developers.facebook.com/docs/messenger-platform/reference/messaging-insights-api#metrics

example

await client.getNewConversations();
// {
//   name: 'page_messages_new_conversations_unique',
//   period: 'day',
//   values: [
//     { value: 1, endTime: '2018-03-12T07:00:00+0000' },
//     { value: 0, endTime: '2018-03-13T07:00:00+0000' },
//   ],
//   title: 'Daily unique new conversations count',
//   description:
//     'Daily: The number of messaging conversations on Facebook Messenger that began with people who had never messaged with your business before.',
//   id:
//     '1386473101668063/insights/page_messages_new_conversations_unique/day',
// }

Parameters

options: InsightOptions
Optional arguments.

Returns Promise<{ name: "page_messages_new_conversations_unique"; period: "day"; values: { endTime: string; value: number | object }[] }>

getPageInfo

getPageInfo(__namedParameters?: { fields?: string[] }): Promise<PageInfo>

- Defined in messaging-api-messenger/src/MessengerClient.ts:237
Gets page info using Graph API.
see
https://developers.facebook.com/docs/graph-api/reference/page/

example
```
await client.getPageInfo();
// {
//   name: 'Bot Demo',
//   id: '1895382890692546',
// }
```
Parameters
- __namedParameters: { fields?: string[] } = {}
  - Optional fields?: string[]
Returns Promise<PageInfo>
Page info

getPageSubscription

getPageSubscription(__namedParameters?: { accessToken?: string }): Promise<MessengerSubscription>

- Defined in messaging-api-messenger/src/MessengerClient.ts:433
Get the current page subscription set up on your app.
see
https://developers.facebook.com/docs/graph-api/reference/app/subscriptions

example
```
await client.getPageSubscription({
  accessToken: APP_ACCESS_TOKEN,
});

// Or provide app id and app secret instead of app access token:
await client.getPageSubscription({
  accessToken: `${APP_ID}|${APP_SECRET}`,
});
```
Parameters
- __namedParameters: { accessToken?: string } = {}
  - Optional accessToken?: string
Returns Promise<MessengerSubscription>
The current page subscription

getPersistentMenu

getPersistentMenu(): Promise<null | PersistentMenu>

Retrieves the current value of persistent menu.

see

https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api/persistent-menu

example

await client.getPersistentMenu();
// [
//   {
//     locale: 'default',
//     composerInputDisabled: true,
//     callToActions: [
//       {
//         type: 'postback',
//         title: 'Restart Conversation',
//         payload: 'RESTART',
//       },
//       {
//         type: 'web_url',
//         title: 'Powered by ALOHA.AI, Yoctol',
//         url: 'https://www.yoctol.com/',
//       },
//     ],
//   },
// ]

Returns Promise<null | PersistentMenu>

Array of persistent menus.

getPersona

getPersona(personaId: string): Promise<{ id: string; name: string; profilePictureUrl: string }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:3611
Retrieves the name and profile picture of a persona.
see
https://developers.facebook.com/docs/messenger-platform/send-messages/personas/#get

example
```
await client.getPersona('PERSONA_ID');
// {
//   "name": "John Mathew",
//   "profile_picture_url": "https://facebook.com/john_image.jpg",
//   "id": "<PERSONA_ID>"
// }
```
Parameters
- personaId: string
  ID of the persona.
Returns Promise<{ id: string; name: string; profilePictureUrl: string }>
Data of the persona

getPersonas

getPersonas(cursor?: string): Promise<{ data: { id: string; name: string; profilePictureUrl: string }[]; paging: { cursors: { after: string; before: string } } }>

Retrieves personas associated with a page using the cursor.

see

https://developers.facebook.com/docs/messenger-platform/send-messages/personas/#retrieve_all

example

await client.getPersonas(cursor);
// {
//   "data": [
//     {
//       "name": "John Mathew",
//       "profile_picture_url": "https://facebook.com/john_image.jpg",
//       "id": "<PERSONA_ID>"
//     },
//     {
//       "name": "David Mark",
//       "profile_picture_url": "https://facebook.com/david_image.jpg",
//       "id": "<PERSONA_ID>"
//     }
//   ],
//   "paging": {
//     "cursors": {
//       "before": "QVFIUlMtR2ZATQlRtVUZALUlloV1",
//       "after": "QVFIUkpnMGx0aTNvUjJNVmJUT0Yw"
//     }
//   }
// }

Parameters

Optional cursor: string
Pagination cursor.

Returns Promise<{ data: { id: string; name: string; profilePictureUrl: string }[]; paging: { cursors: { after: string; before: string } } }>

Persona data in pagination result

getReportedConversations

getReportedConversations(options: InsightOptions): Promise<{ name: "page_messages_reported_conversations_unique"; period: "day"; values: { endTime: string; value: number | object }[] }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:3134
Retrieves the number of conversations from your Page that have been reported by people for reasons such as spam, or containing inappropriate content.
see
https://developers.facebook.com/docs/messenger-platform/reference/messaging-insights-api#metrics

example
```
await client.getReportedConversations();
// {
//   "name": "page_messages_reported_conversations_unique",
//   "period": "day",
//   "values": [
//     {
//       "value": "<VALUE>",
//       "endTime": "<UTC_TIMESTAMP>"
//     },
//     {
//       "value": "<VALUE>",
//       "endTime": "<UTC_TIMESTAMP>"
//     }
//   ]
// }
```
Parameters
- options: InsightOptions
  Optional arguments.
Returns Promise<{ name: "page_messages_reported_conversations_unique"; period: "day"; values: { endTime: string; value: number | object }[] }>

getSecondaryReceivers

getSecondaryReceivers(): Promise<{ id: string; name: string }[]>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2963
Retrieves the list of apps that are Secondary Receivers for a page.
see
https://developers.facebook.com/docs/messenger-platform/reference/handover-protocol/secondary-receivers

example
```
await client.getSecondaryReceivers();
// [
//   {
//     "id": "12345678910",
//     "name": "David's Composer"
//   },
//   {
//     "id": "23456789101",
//     "name": "Messenger Rocks"
//   }
// ]
```
Returns Promise<{ id: string; name: string }[]>
An array of secondary receivers.

getSubscriptions

getSubscriptions(__namedParameters?: { accessToken?: string }): Promise<MessengerSubscription[]>

Gets the current Webhook subscriptions set up on your app.

see

https://developers.facebook.com/docs/graph-api/reference/app/subscriptions

example

await client.getSubscriptions({
  accessToken: APP_ACCESS_TOKEN,
});
// [{
//   object: 'page',
//   callbackUrl: 'https://www.example.com/callback'
//   fields: ['messages', 'messaging_postbacks', 'messaging_optins'],
//   active: true,
// }]

// Or provide app id and app secret instead of app access token:
await client.getSubscriptions({
  accessToken: `${APP_ID}|${APP_SECRET}`,
});

Parameters

__namedParameters: { accessToken?: string } = {}
- Optional accessToken?: string

Returns Promise<MessengerSubscription[]>

An array of subscriptions.

getThreadOwner

getThreadOwner(recipientId: string): Promise<{ appId: string }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2999
Gets the current thread owner.
see
https://developers.facebook.com/docs/messenger-platform/handover-protocol/get-thread-owner

example
```
await client.getThreadOwner(USER_ID);
// {
//   appId: '12345678910'
// }
```
Parameters
- recipientId: string
  The PSID of the message recipient.
Returns Promise<{ appId: string }>
App Id of the current thread owner.

getTotalMessagingConnections

getTotalMessagingConnections(options: InsightOptions): Promise<{ name: "page_messages_total_messaging_connections"; period: "day"; values: { endTime: string; value: number | object }[] }>

Retrieves the number of people who have sent a message to your business, not including people who have blocked or reported your business on Messenger. (This number only includes connections made since October 2016.)

see

https://developers.facebook.com/docs/messenger-platform/reference/messaging-insights-api#metrics

example

await client.getTotalMessagingConnections();
// {
//   name: 'page_messages_total_messaging_connections',
//   period: 'day',
//   values: [
//     { value: 1000, endTime: '2018-03-12T07:00:00+0000' },
//     { value: 1000, endTime: '2018-03-13T07:00:00+0000' },
//   ],
//   title: 'Messaging connections',
//   description:
//     'Daily: The number of people who have sent a message to your business, not including people who have blocked or reported your business on Messenger. (This number only includes connections made since October 2016.)',
//   id:
//     '1386473101668063/insights/page_messages_total_messaging_connections/day',
// }

Parameters

options: InsightOptions
Optional arguments.

Returns Promise<{ name: "page_messages_total_messaging_connections"; period: "day"; values: { endTime: string; value: number | object }[] }>

getUserField

getUserField(__namedParameters: { app?: string; appSecret: string; field: string; page?: string; userId: string }): Promise<any>

- Defined in messaging-api-messenger/src/MessengerClient.ts:3362
see
https://developers.facebook.com/docs/messenger-platform/identity/id-matching#examples

example
Parameters
- __namedParameters: { app?: string; appSecret: string; field: string; page?: string; userId: string }
  - Optional app?: string
  - appSecret: string
  - field: string
  - Optional page?: string
  - userId: string
Returns Promise<any>

getUserPersistentMenu

getUserPersistentMenu(userId: string): Promise<null | PersistentMenu>

- Defined in messaging-api-messenger/src/MessengerClient.ts:838
User Level Persistent Menu
see
https://developers.facebook.com/docs/messenger-platform/send-messages/persistent-menu#user_level_menu

example
Parameters
- userId: string
Returns Promise<null | PersistentMenu>

getUserProfile

getUserProfile(userId: string, __namedParameters?: { fields?: UserProfileField[] }): Promise<User>

- Defined in messaging-api-messenger/src/MessengerClient.ts:505
Retrieves a person's profile.
see
https://www.quora.com/How-connect-Facebook-user-id-to-sender-id-in-the-Facebook-messenger-platform

example
```
await client.getUserProfile(USER_ID);
// {
//   id: '5566'
//   firstName: 'Johnathan',
//   lastName: 'Jackson',
//   profilePic: 'https://example.com/pic.png',
// }
```
Parameters
- userId: string
  Facebook page-scoped user ID.
- __namedParameters: { fields?: UserProfileField[] } = {}
  - Optional fields?: UserProfileField[]
Returns Promise<User>
Profile of the user.

getWhitelistedDomains

getWhitelistedDomains(): Promise<null | string[]>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1088
Retrieves the current value of whitelisted domains.
see
https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api/domain-whitelisting

example
```
await client.getWhitelistedDomains();
// ['http://www.example.com/']
```
Returns Promise<null | string[]>
Array of whitelisted domains.

logCustomEvents

logCustomEvents(__namedParameters: { appId: number; events: Record<string, any>[]; pageId: number; pageScopedUserId: string }): Promise<any>

- Defined in messaging-api-messenger/src/MessengerClient.ts:3332
Logs custom events by using the Application Activities Graph API endpoint.
see
https://developers.facebook.com/docs/app-events/bots-for-messenger#logging-custom-events

example
```
await client.logCustomEvents({
  appId: APP_ID,
  pageId: PAGE_ID,
  pageScopedUserId: USER_ID,
  events: [
    {
      _eventName: 'fb_mobile_purchase',
      _valueToSum: 55.22,
      _fbCurrency: 'USD',
    },
  ],
});
```
Parameters
- __namedParameters: { appId: number; events: Record<string, any>[]; pageId: number; pageScopedUserId: string }
  - appId: number
  - events: Record<string, any>[]
  - pageId: number
  - pageScopedUserId: string
Returns Promise<any>

markSeen

markSeen(psidOrRecipient: PsidOrRecipient): Promise<SendSenderActionResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2211
Marks last message as read for the specified user.
see
https://developers.facebook.com/docs/messenger-platform/send-messages/sender-actions#supported_actions

example
```
await client.markSeen(USER_ID);
```
Parameters
- psidOrRecipient: PsidOrRecipient
  A facebook page-scoped ID of the recipient or a recipient object
Returns Promise<SendSenderActionResponse>
An object includes recipientId

passThreadControl

passThreadControl(recipientId: string, targetAppId: number, metadata?: string): Promise<{ success: true }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2838
Passes thread control from your app to another app.
see
https://developers.facebook.com/docs/messenger-platform/reference/handover-protocol/pass-thread-control

example
```
await client.passThreadControl(USER_ID, APP_ID, 'free formed text for another app');
```
Parameters
- recipientId: string
  The PSID of the message recipient.
- targetAppId: number
  The app ID of the Secondary Receiver to pass thread control to.
- Optional metadata: string
  Metadata passed to the receiving app in the pass_thread_control webhook event.
Returns Promise<{ success: true }>
Success status.

passThreadControlToPageInbox

passThreadControlToPageInbox(recipientId: string, metadata?: string): Promise<{ success: true }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2873
Passes thread control from your app to "Page Inbox" app.
see
https://developers.facebook.com/docs/messenger-platform/handover-protocol/pass-thread-control#page_inbox

example
```
await client.passThreadControlToPageInbox(
  USER_ID,
  'free formed text for another app'
);
```
Parameters
- recipientId: string
  The PSID of the message recipient.
- Optional metadata: string
  Metadata passed to the receiving app in the pass_thread_control webhook event.
Returns Promise<{ success: true }>
Success status.

requestThreadControl

requestThreadControl(recipientId: string, metadata?: string): Promise<{ success: true }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2925
Requests control of a specific thread from a Primary Receiver app.
see
https://developers.facebook.com/docs/messenger-platform/handover-protocol/request-thread-control/

example
```
await client.requestThreadControl(USER_ID, 'free formed text for primary app');
```
Parameters
- recipientId: string
  The PSID of the message recipient.
- Optional metadata: string
  Metadata passed to the primary app in the request_thread_control webhook event.
Returns Promise<{ success: true }>
Success status.

sendAirlineBoardingPassTemplate

sendAirlineBoardingPassTemplate(psidOrRecipient: PsidOrRecipient, attrs: AirlineBoardingPassAttributes, options?: SendOption): Promise<SendMessageSuccessResponse>

Sends airline boarding pass template messages to the specified user using the Send API.

see

https://developers.facebook.com/docs/messenger-platform/send-messages/template/airline#boarding_pass

example

await client.sendAirlineBoardingPassTemplate(RECIPIENT_ID, {
  introMessage: 'You are checked in.',
  locale: 'en_US',
  boardingPass: [
    {
      passengerName: 'SMITH/NICOLAS',
      pnrNumber: 'CG4X7U',
      travelClass: 'business',
      seat: '74J',
      auxiliaryFields: [
        {
          label: 'Terminal',
          value: 'T1',
        },
        {
          label: 'Departure',
          value: '30OCT 19:05',
        },
      ],
      secondaryFields: [
        {
          label: 'Boarding',
          value: '18:30',
        },
        {
          label: 'Gate',
          value: 'D57',
        },
        {
          label: 'Seat',
          value: '74J',
        },
        {
          label: 'Sec.Nr.',
          value: '003',
        },
      ],
      logoImageUrl: 'https://www.example.com/en/logo.png',
      headerImageUrl: 'https://www.example.com/en/fb/header.png',
      qrCode: 'M1SMITH/NICOLAS  CG4X7U nawouehgawgnapwi3jfa0wfh',
      aboveBarCodeImageUrl: 'https://www.example.com/en/PLAT.png',
      flightInfo: {
        flightNumber: 'KL0642',
        departureAirport: {
          airportCode: 'JFK',
          city: 'New York',
          terminal: 'T1',
          gate: 'D57',
        },
        arrivalAirport: {
          airportCode: 'AMS',
          city: 'Amsterdam',
        },
        flightSchedule: {
          departureTime: '2016-01-02T19:05',
          arrivalTime: '2016-01-05T17:30',
        },
      },
    },
  ],
});

Parameters

psidOrRecipient: PsidOrRecipient
A facebook page-scoped ID of the recipient or a recipient object
attrs: AirlineBoardingPassAttributes
payload of boarding pass template.
Optional options: SendOption
Other optional parameters. For example, messaging types or tags.

Returns Promise<SendMessageSuccessResponse>

An object includes recipientId and messageId.

sendAirlineCheckinTemplate

sendAirlineCheckinTemplate(psidOrRecipient: PsidOrRecipient, attrs: AirlineCheckinAttributes, options?: SendOption): Promise<SendMessageSuccessResponse>

Send airline check-in template messages to the specified user using the Send API.

see

https://developers.facebook.com/docs/messenger-platform/send-messages/template/airline#check_in

example

await client.sendAirlineCheckinTemplate(USER_ID, {
  introMessage: 'Check-in is available now.',
  locale: 'en_US',
  pnrNumber: 'ABCDEF',
  flightInfo: [
    {
      flightNumber: 'f001',
      departureAirport: {
        airportCode: 'SFO',
        city: 'San Francisco',
        terminal: 'T4',
        gate: 'G8',
      },
      arrivalAirport: {
        airportCode: 'SEA',
        city: 'Seattle',
        terminal: 'T4',
        gate: 'G8',
      },
      flightSchedule: {
        boardingTime: '2016-01-05T15:05',
        departureTime: '2016-01-05T15:45',
        arrivalTime: '2016-01-05T17:30',
      },
    },
  ],
  checkinUrl: 'https://www.airline.com/check-in',
});

Parameters

psidOrRecipient: PsidOrRecipient
A facebook page-scoped ID of the recipient or a recipient object
attrs: AirlineCheckinAttributes
payload of check-in template.
Optional options: SendOption
Other optional parameters. For example, messaging types or tags.

Returns Promise<SendMessageSuccessResponse>

An object includes recipientId and messageId.

sendAirlineItineraryTemplate

sendAirlineItineraryTemplate(psidOrRecipient: PsidOrRecipient, attrs: AirlineItineraryAttributes, options?: SendOption): Promise<SendMessageSuccessResponse>

Send airline itinerary template messages to the specified user using the Send API.

see

https://developers.facebook.com/docs/messenger-platform/send-messages/template/airline#itinerary

example

await client.sendAirlineItineraryTemplate(USER_ID, {
  introMessage: "Here's your flight itinerary.",
  locale: 'en_US',
  pnrNumber: 'ABCDEF',
  passengerInfo: [
    {
      name: 'Farbound Smith Jr',
      ticketNumber: '0741234567890',
      passengerId: 'p001',
    },
    {
      name: 'Nick Jones',
      ticketNumber: '0741234567891',
      passengerId: 'p002',
    },
  ],
  flightInfo: [
    {
      connectionId: 'c001',
      segmentId: 's001',
      flightNumber: 'KL9123',
      aircraftType: 'Boeing 737',
      departureAirport: {
        airportCode: 'SFO',
        city: 'San Francisco',
        terminal: 'T4',
        gate: 'G8',
      },
      arrivalAirport: {
        airportCode: 'SLC',
        city: 'Salt Lake City',
        terminal: 'T4',
        gate: 'G8',
      },
      flightSchedule: {
        departureTime: '2016-01-02T19:45',
        arrivalTime: '2016-01-02T21:20',
      },
      travelClass: 'business',
    },
  ],
  passengerSegmentInfo: [
    {
      segmentId: 's001',
      passengerId: 'p001',
      seat: '12A',
      seatType: 'Business',
    },
    {
      segmentId: 's001',
      passengerId: 'p002',
      seat: '12B',
      seatType: 'Business',
    },
  ],
  priceInfo: [
    {
      title: 'Fuel surcharge',
      amount: '1597',
      currency: 'USD',
    },
  ],
  basePrice: '12206',
  tax: '200',
  totalPrice: '14003',
  currency: 'USD',
});

Parameters

psidOrRecipient: PsidOrRecipient
A facebook page-scoped ID of the recipient or a recipient object
attrs: AirlineItineraryAttributes
payload of itinerary template.
Optional options: SendOption
Other optional parameters. For example, messaging types or tags.

Returns Promise<SendMessageSuccessResponse>

An object includes recipientId and messageId.

sendAirlineUpdateTemplate

sendAirlineUpdateTemplate(psidOrRecipient: PsidOrRecipient, attrs: AirlineUpdateAttributes, options?: SendOption): Promise<SendMessageSuccessResponse>

Sends airline flight update template messages to the specified user using the Send API.

see

https://developers.facebook.com/docs/messenger-platform/send-messages/template/airline#update

example

await client.sendAirlineUpdateTemplate(USER_ID, {
  introMessage: 'Your flight is delayed',
  updateType: 'delay',
  locale: 'en_US',
  pnrNumber: 'CF23G2',
  updateFlightInfo: {
    flightNumber: 'KL123',
    departureAirport: {
      airportCode: 'SFO',
      city: 'San Francisco',
      terminal: 'T4',
      gate: 'G8',
    },
    arrivalAirport: {
      airportCode: 'AMS',
      city: 'Amsterdam',
      terminal: 'T4',
      gate: 'G8',
    },
    flightSchedule: {
      boardingTime: '2015-12-26T10:30',
      departureTime: '2015-12-26T11:30',
      arrivalTime: '2015-12-27T07:30',
    },
  },
});

Parameters

psidOrRecipient: PsidOrRecipient
A facebook page-scoped ID of the recipient or a recipient object
attrs: AirlineUpdateAttributes
payload of update template.
Optional options: SendOption
Other optional parameters. For example, messaging types or tags.

Returns Promise<SendMessageSuccessResponse>

An object includes recipientId and messageId.

sendAttachment

sendAttachment(psidOrRecipient: PsidOrRecipient, attachment: Attachment, options?: SendOption): Promise<SendMessageSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1353
Sends attachment messages to the specified user using the Send API.
see
https://developers.facebook.com/docs/messenger-platform/send-messages#sending_attachments

example
```
await client.sendAttachment(USER_ID, {
  type: 'image',
  payload: {
    url: 'https://example.com/pic.png',
  },
});
```
Parameters
- psidOrRecipient: PsidOrRecipient
  A facebook page-scoped ID of the recipient or a recipient object
- attachment: Attachment
  The attachment of media or template to be sent.
- Optional options: SendOption
  Other optional parameters. For example, messaging types or tags.
Returns Promise<SendMessageSuccessResponse>
An object includes recipientId and messageId.

sendAudio

sendAudio(psidOrRecipient: PsidOrRecipient, audio: string | FileData | MediaAttachmentPayload, options?: SendOption): Promise<SendMessageSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1421
Sends sounds to the specified user by uploading them or sharing a URL using the Send API.
see
https://developers.facebook.com/docs/messenger-platform/send-messages#types

example
```
// Send audio using url string:
await client.sendAudio(USER_ID, 'https://example.com/audio.mp3');

// Use `AttachmentPayload` to send cached attachment:
await client.sendAudio(USER_ID, { attachmentId: '55688' });

// Use `ReadStream` created from the local file:
const fs = require('fs');
await client.sendAudio(USER_ID, fs.createReadStream('audio.mp3'));

// Use `Buffer` to send attachment:
await client.sendAudio(USER_ID, buffer, { filename: 'audio.mp3' });
```
Parameters
- psidOrRecipient: PsidOrRecipient
  A facebook page-scoped ID of the recipient or a recipient object
- audio: string | FileData | MediaAttachmentPayload
  The audio to be sent.
- Optional options: SendOption
  Other optional parameters. For example, messaging types or tags.
Returns Promise<SendMessageSuccessResponse>
An object includes recipientId and messageId.

sendBatch

sendBatch(batch: BatchItem[], __namedParameters?: { includeHeaders?: boolean }): Promise<{ body: Record<string, any>; code: number; headers?: { name: string; value: string }[] }[]>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2288
Sends multiple requests in a batch.
see
https://developers.facebook.com/docs/graph-api/making-multiple-requests

example
```
const { MessengerBatch } = require('messaging-api-messenger');

await client.sendBatch([
  MessengerBatch.sendText(USER_ID, '1'),
  MessengerBatch.sendText(USER_ID, '2'),
  MessengerBatch.sendText(USER_ID, '3'),
]);
```
Parameters
- batch: BatchItem[]
- __namedParameters: { includeHeaders?: boolean } = {}
  - Optional includeHeaders?: boolean
Returns Promise<{ body: Record<string, any>; code: number; headers?: { name: string; value: string }[] }[]>
An array of batch results

sendButtonTemplate

sendButtonTemplate(psidOrRecipient: PsidOrRecipient, text: string, buttons: TemplateButton[], options?: SendOption): Promise<SendMessageSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1641
Sends button template messages to the specified user using the Send API.
see
https://developers.facebook.com/docs/messenger-platform/send-messages/template/button

example
```
await client.sendButtonTemplate(USER_ID, 'What do you want to do next?', [
  {
    type: 'web_url',
    url: 'https://petersapparel.parseapp.com',
    title: 'Show Website',
  },
  {
    type: 'postback',
    title: 'Start Chatting',
    payload: 'USER_DEFINED_PAYLOAD',
  },
]);
```
Parameters
- psidOrRecipient: PsidOrRecipient
  A facebook page-scoped ID of the recipient or a recipient object
- text: string
- buttons: TemplateButton[]
  Array of button. Set of 1-3 buttons that appear as call-to-actions.
- Optional options: SendOption
  Other optional parameters. For example, messaging types or tags.
Returns Promise<SendMessageSuccessResponse>
An object includes recipientId and messageId.

sendFile

sendFile(psidOrRecipient: PsidOrRecipient, file: string | FileData | MediaAttachmentPayload, options?: SendOption): Promise<SendMessageSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1556
Sends files to the specified user by uploading them or sharing a URL using the Send API.
see
https://developers.facebook.com/docs/messenger-platform/send-messages#types

example
```
// Send file using url string:
await client.sendFile(USER_ID, 'https://example.com/file.pdf');

// Use `AttachmentPayload` to send cached attachment:
await client.sendFile(USER_ID, { attachmentId: '55688' });

// Use `ReadStream` created from the local file:
const fs = require('fs');
await client.sendFile(USER_ID, fs.createReadStream('file.pdf'));

// Use `Buffer` to send attachment:
await client.sendFile(USER_ID, buffer, { filename: 'file.pdf' });
```
Parameters
- psidOrRecipient: PsidOrRecipient
  A facebook page-scoped ID of the recipient or a recipient object
- file: string | FileData | MediaAttachmentPayload
  The file to be sent.
- Optional options: SendOption
  Other optional parameters. For example, messaging types or tags.
Returns Promise<SendMessageSuccessResponse>
An object includes recipientId and messageId.

sendGenericTemplate

sendGenericTemplate(psidOrRecipient: PsidOrRecipient, elements: TemplateElement[], options?: { imageAspectRatio?: "horizontal" | "square" } & SendOption): Promise<SendMessageSuccessResponse>

Sends generic template messages to the specified user using the Send API.

see

https://developers.facebook.com/docs/messenger-platform/send-messages/template/generic

example

await client.sendGenericTemplate(
  USER_ID,
  [
    {
      title: "Welcome to Peter's Hats",
      imageUrl: 'https://petersfancybrownhats.com/company_image.png',
      subtitle: "We've got the right hat for everyone.",
      defaultAction: {
        type: 'web_url',
        url: 'https://peterssendreceiveapp.ngrok.io/view?item=103',
        messengerExtensions: true,
        webviewHeightRatio: 'tall',
        fallbackUrl: 'https://peterssendreceiveapp.ngrok.io/',
      },
      buttons: [
        {
          type: 'postback',
          title: 'Start Chatting',
          payload: 'DEVELOPER_DEFINED_PAYLOAD',
        },
      ],
    },
  ],
  { imageAspectRatio: 'square' }
);

Parameters

psidOrRecipient: PsidOrRecipient
A facebook page-scoped ID of the recipient or a recipient object
elements: TemplateElement[]
Array of element. Data for each bubble in message.
options: { imageAspectRatio?: "horizontal" | "square" } & SendOption = {}
Other optional parameters, such as image_aspect_ratio, messaging types and tags.

Returns Promise<SendMessageSuccessResponse>

An object includes recipientId and messageId.

sendImage

sendImage(psidOrRecipient: PsidOrRecipient, image: string | FileData | MediaAttachmentPayload, options?: SendOption): Promise<SendMessageSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1466
Sends images to the specified user by uploading them or sharing a URL using the Send API. Supported formats are jpg, png and gif.
see
https://developers.facebook.com/docs/messenger-platform/send-messages#types

example
```
// Send image using url string:
await client.sendImage(USER_ID, 'https://example.com/image.jpg');

// Use `AttachmentPayload` to send cached attachment:
await client.sendImage(USER_ID, { attachmentId: '55688' });

// Use `ReadStream` created from the local file:
const fs = require('fs');
await client.sendImage(USER_ID, fs.createReadStream('image.jpg'));

// Use `Buffer` to send attachment:
await client.sendImage(USER_ID, buffer, { filename: 'image.jpg' });
```
Parameters
- psidOrRecipient: PsidOrRecipient
  A facebook page-scoped ID of the recipient or a recipient object
- image: string | FileData | MediaAttachmentPayload
  The image to be sent.
- Optional options: SendOption
  Other optional parameters. For example, messaging types or tags.
Returns Promise<SendMessageSuccessResponse>
An object includes recipientId and messageId.

sendMediaTemplate

sendMediaTemplate(psidOrRecipient: PsidOrRecipient, elements: MediaElement[], options?: SendOption): Promise<SendMessageSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1818
Sends media template messages to the specified user using the Send API.
see
https://developers.facebook.com/docs/messenger-platform/send-messages/template/media

example
```
await client.sendMediaTemplate(USER_ID, [
  {
    mediaType: 'image',
    attachmentId: '1854626884821032',
    buttons: [
      {
        type: 'web_url',
        url: 'https://en.wikipedia.org/wiki/Rickrolling',
        title: 'View Website',
      },
    ],
  },
]);
```
Parameters
- psidOrRecipient: PsidOrRecipient
  A facebook page-scoped ID of the recipient or a recipient object
- elements: MediaElement[]
  Array of element. Only one element is allowed.
- Optional options: SendOption
  Other optional parameters. For example, messaging types or tags.
Returns Promise<SendMessageSuccessResponse>
An object includes recipientId and messageId.

sendMessage

sendMessage(psidOrRecipient: PsidOrRecipient, message: Message, options?: SendOption): Promise<SendMessageSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1261
Sends messages to the specified user using the Send API.
example
```
await client.sendMessage(USER_ID, {
  text: 'Hello!',
});
```
You can specify messaging type using options. If messagingType and tag is not provided, UPDATE will be used as default messaging type.
```
await client.sendMessage(
  USER_ID,
  { text: 'Hello!' },
  { messagingType: 'RESPONSE' }
);
```
Available messaging types:
- UPDATE as default
- RESPONSE using { messagingType: 'RESPONSE' } options
- MESSAGE_TAG using { tag: 'ANY_TAG' } options
Parameters
- psidOrRecipient: PsidOrRecipient
  A facebook page-scoped ID of the recipient or a recipient object
- message: Message
  A message object.
- options: SendOption = {}
  Other optional parameters. For example, messaging types or tags.
Returns Promise<SendMessageSuccessResponse>
An object includes recipientId and messageId.

sendMessageFormData

sendMessageFormData(psidOrRecipient: PsidOrRecipient, formdata: FormData, options?: SendOption): Promise<SendMessageSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1299
Sends messages to the specified user using the Send API with form-data format.

example
Parameters
- psidOrRecipient: PsidOrRecipient
  A facebook page-scoped ID of the recipient or a recipient object
- formdata: FormData
  A FromData object
- options: SendOption = {}
  Other optional parameters. For example, messaging types or tags.
Returns Promise<SendMessageSuccessResponse>
An object includes recipientId and messageId.

sendOneTimeNotifReqTemplate

sendOneTimeNotifReqTemplate(psidOrRecipient: PsidOrRecipient, attrs: OneTimeNotifReqAttributes, options?: SendOption): Promise<SendMessageSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2147
see
https://developers.facebook.com/docs/messenger-platform/send-messages/one-time-notification/#one-time-notif

example
```
await client.sendOneTimeNotifReqTemplate(USER_ID, {
  title: '<TITLE_TEXT>',
  payload: '<USER_DEFINED_PAYLOAD>',
});
```
Parameters
- psidOrRecipient: PsidOrRecipient
  A facebook page-scoped ID of the recipient or a recipient object
- attrs: OneTimeNotifReqAttributes
- Optional options: SendOption
  Other optional parameters. For example, messaging types or tags.
Returns Promise<SendMessageSuccessResponse>
An object includes recipientId and messageId.

sendRawBody

sendRawBody(body: Record<string, any>): Promise<SendMessageSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1219
Sends request raw body using the Send API.
see
https://developers.facebook.com/docs/messenger-platform/reference/send-api#request

example
```
await client.sendRawBody({
  recipient: {
    id: USER_ID,
  },
  message: {
    text: 'Hello!',
  },
});
// {
//   recipientId: '1254477777772919',
//   messageId: 'AG5Hz2Uq7tuwNEhXfYYKj8mJEM_QPpz5jdCK48PnKAjSdjfipqxqMvK8ma6AC8fplwlqLP_5cgXIbu7I3rBN0P'
// }
```
Parameters
- body: Record<string, any>
  The raw body to be sent.
Returns Promise<SendMessageSuccessResponse>
An object includes recipientId and messageId.

sendReceiptTemplate

sendReceiptTemplate(psidOrRecipient: PsidOrRecipient, receipt: ReceiptAttributes, options?: SendOption): Promise<SendMessageSuccessResponse>

Sends receipt template messages to the specified user using the Send API.

see

https://developers.facebook.com/docs/messenger-platform/send-messages/template/receipt

example

await client.sendReceiptTemplate(USER_ID, {
  recipientName: 'Stephane Crozatier',
  orderNumber: '12345678902',
  currency: 'USD',
  paymentMethod: 'Visa 2345',
  orderUrl: 'http://petersapparel.parseapp.com/order?order_id=123456',
  timestamp: '1428444852',
  elements: [
    {
      title: 'Classic White T-Shirt',
      subtitle: '100% Soft and Luxurious Cotton',
      quantity: 2,
      price: 50,
      currency: 'USD',
      imageUrl: 'http://petersapparel.parseapp.com/img/whiteshirt.png',
    },
    {
      title: 'Classic Gray T-Shirt',
      subtitle: '100% Soft and Luxurious Cotton',
      quantity: 1,
      price: 25,
      currency: 'USD',
      imageUrl: 'http://petersapparel.parseapp.com/img/grayshirt.png',
    },
  ],
  address: {
    street1: '1 Hacker Way',
    street2: '',
    city: 'Menlo Park',
    postalCode: '94025',
    state: 'CA',
    country: 'US',
  },
  summary: {
    subtotal: 75.0,
    shippingCost: 4.95,
    totalTax: 6.19,
    totalCost: 56.14,
  },
  adjustments: [
    {
      name: 'New Customer Discount',
      amount: 20,
    },
    {
      name: '$10 Off Coupon',
      amount: 10,
    },
  ],
});

Parameters

psidOrRecipient: PsidOrRecipient
A facebook page-scoped ID of the recipient or a recipient object
receipt: ReceiptAttributes
payload of receipt template.
Optional options: SendOption
Other optional parameters. For example, messaging types or tags.

Returns Promise<SendMessageSuccessResponse>

An object includes recipientId and messageId.

sendSenderAction

sendSenderAction(psidOrRecipient: PsidOrRecipient, senderAction: SenderAction, options?: SenderActionOption): Promise<SendSenderActionResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2179
Sends sender actions to specified user using the Send API, to let users know you are processing their requests.
see
https://developers.facebook.com/docs/messenger-platform/send-messages/sender-actions

example
```
await client.sendSenderAction(USER_ID, 'typing_on');

// Or with persona:
await client.sendSenderAction(USER_ID, 'typing_on', { personaId: '<PERSONA_ID>' });
```
Parameters
- psidOrRecipient: PsidOrRecipient
  A facebook page-scoped ID of the recipient or a recipient object
- senderAction: SenderAction
  Message state to display to the user. One of typing_on, typing_off or mark_seen
- Optional options: SenderActionOption
  Other optional parameters.
Returns Promise<SendSenderActionResponse>
An object includes recipientId

sendTemplate

sendTemplate(psidOrRecipient: PsidOrRecipient, payload: TemplateAttachmentPayload, options?: SendOption): Promise<SendMessageSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1599
Sends structured template messages to the specified user using the Send API.
see
https://developers.facebook.com/docs/messenger-platform/send-messages/templates

example
```
await client.sendTemplate(USER_ID, {
  templateType: 'button',
  text: 'title',
  buttons: [
    {
      type: 'postback',
      title: 'Start Chatting',
      payload: 'USER_DEFINED_PAYLOAD',
    },
  ],
});
```
Parameters
- psidOrRecipient: PsidOrRecipient
  A facebook page-scoped ID of the recipient or a recipient object
- payload: TemplateAttachmentPayload
  The template object.
- Optional options: SendOption
  Other optional parameters. For example, messaging types or tags.
Returns Promise<SendMessageSuccessResponse>
An object includes recipientId and messageId.

sendText

sendText(psidOrRecipient: PsidOrRecipient, text: string, options?: SendOption): Promise<SendMessageSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1381
Sends plain text messages to the specified user using the Send API.
see
https://developers.facebook.com/docs/messenger-platform/send-messages#sending_text

example
```
await client.sendText(USER_ID, 'Hello!', { tag: 'CONFIRMED_EVENT_UPDATE' });
```
Parameters
- psidOrRecipient: PsidOrRecipient
  A facebook page-scoped ID of the recipient or a recipient object
- text: string
  The text to be sent.
- Optional options: SendOption
  Other optional parameters. For example, messaging types or tags.
Returns Promise<SendMessageSuccessResponse>
An object includes recipientId and messageId.

sendVideo

sendVideo(psidOrRecipient: PsidOrRecipient, video: string | FileData | MediaAttachmentPayload, options?: SendOption): Promise<SendMessageSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1511
Sends videos to the specified user by uploading them or sharing a URL using the Send API.
see
https://developers.facebook.com/docs/messenger-platform/send-messages#types

example
```
// Send video using url string:
await client.sendVideo(USER_ID, 'https://example.com/video.mp4');

// Use `AttachmentPayload` to send cached attachment:
await client.sendVideo(USER_ID, { attachmentId: '55688' });

// Use `ReadStream` created from the local file:
const fs = require('fs');
await client.sendVideo(USER_ID, fs.createReadStream('video.mp4'));

// Use `Buffer` to send attachment:
await client.sendVideo(USER_ID, buffer, { filename: 'video.mp4' });
```
Parameters
- psidOrRecipient: PsidOrRecipient
  A facebook page-scoped ID of the recipient or a recipient object
- video: string | FileData | MediaAttachmentPayload
  The video to be sent.
- Optional options: SendOption
  Other optional parameters. For example, messaging types or tags.
Returns Promise<SendMessageSuccessResponse>
An object includes recipientId and messageId.

setAccountLinkingURL

setAccountLinkingURL(accountLinkingUrl: string): Promise<MutationSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1169
Sets the values of account linking URL.
see
https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api/account-linking-url

example
```
await client.setAccountLinkingURL(
  'https://www.example.com/oauth?response_type=code&client_id=1234567890&scope=basic'
);
```
Parameters
- accountLinkingUrl: string
Returns Promise<MutationSuccessResponse>
Success status

setGetStarted

setGetStarted(payload: string): Promise<MutationSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:679
Sets the values of get started button.
see
https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api/get-started-button

example
- await client.setGetStarted('GET_STARTED');
Parameters
- payload: string
  Payload sent back to your webhook in a messaging_postbacks event when the 'Get Started' button is tapped.
Returns Promise<MutationSuccessResponse>
Success status

setGreeting

setGreeting(greeting: string | GreetingConfig[]): Promise<MutationSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:965
Sets the values of greeting text.
see
https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api/greeting

example
```
await client.setGreeting([
  {
    locale: 'default',
    text: 'Hello!',
  },
]);
```
Parameters
- greeting: string | GreetingConfig[]
  Array of greeting.
Returns Promise<MutationSuccessResponse>
Success status

setIceBreakers

setIceBreakers(iceBreakers: IceBreaker[]): Promise<MutationSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1051
Sets the values of ice breakers.
example
```
await client.setIceBreakers([
  {
    question: '<QUESTION>',
    payload: '<PAYLOAD>',
  },
  {
    question: '<QUESTION>',
    payload: '<PAYLOAD>',
  }
]);
```
Parameters
- iceBreakers: IceBreaker[]
  Array of ice breakers.
Returns Promise<MutationSuccessResponse>
Success status

setMessengerProfile

setMessengerProfile(profile: MessengerProfile): Promise<MutationSuccessResponse>

Sets the values of one or more Messenger Profile properties. Only properties set in the request body will be overwritten.

see

https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api#post

example

await client.setMessengerProfile({
  getStarted: {
    payload: 'GET_STARTED',
  },
  persistentMenu: [
    {
      locale: 'default',
      composerInputDisabled: true,
      callToActions: [
        {
          type: 'postback',
          title: 'Restart Conversation',
          payload: 'RESTART',
        },
      ],
    },
  ],
});

Parameters

profile: MessengerProfile
Profile object.

Returns Promise<MutationSuccessResponse>

Success status

setNLPConfigs

setNLPConfigs(config?: MessengerNLPConfig): Promise<any>

- Defined in messaging-api-messenger/src/MessengerClient.ts:3254
Sets values of NLP configs.
see
https://developers.facebook.com/docs/messenger-platform/built-in-nlp

example
```
await client.setNLPConfigs({ nlpEnabled: true });
```
Parameters
- config: MessengerNLPConfig = {}
  Configuration of NLP.
Returns Promise<any>

setPersistentMenu

setPersistentMenu(menuItems: TemplateButton[] | PersistentMenuItem[], __namedParameters?: { composerInputDisabled?: boolean }): Promise<MutationSuccessResponse>

Sets the values of persistent menu.

see

https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api/persistent-menu

example

await client.setPersistentMenu([
  {
    locale: 'default',
    callToActions: [
      {
        title: 'Play Again',
        type: 'postback',
        payload: 'RESTART',
      },
      {
        title: 'Explore',
        type: 'web_url',
        url: 'https://www.youtube.com/watch?v=v',
        webviewHeightRatio: 'tall',
      },
      {
        title: 'Powered by YOCTOL',
        type: 'web_url',
        url: 'https://www.yoctol.com/',
        webviewHeightRatio: 'tall',
      },
    ],
  },
]);

note

You must set a get started button to use the persistent menu.

Parameters

menuItems: TemplateButton[] | PersistentMenuItem[]
__namedParameters: { composerInputDisabled?: boolean } = {}
- Optional composerInputDisabled?: boolean

Returns Promise<MutationSuccessResponse>

setUserPersistentMenu

setUserPersistentMenu(userId: string, menuItems: TemplateButton[] | PersistentMenuItem[], __namedParameters?: { composerInputDisabled?: boolean }): Promise<MutationSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:862
example
Parameters
- userId: string
- menuItems: TemplateButton[] | PersistentMenuItem[]
- __namedParameters: { composerInputDisabled?: boolean } = {}
  - Optional composerInputDisabled?: boolean
Returns Promise<MutationSuccessResponse>

setWhitelistedDomains

setWhitelistedDomains(whitelistedDomains: string[]): Promise<MutationSuccessResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:1108
Sets the values of whitelisted domains.
see
https://developers.facebook.com/docs/messenger-platform/reference/messenger-profile-api/domain-whitelisting

example
```
await client.setWhitelistedDomains(['www.example.com']);
```
Parameters
- whitelistedDomains: string[]
  Array of whitelisted_domain.
Returns Promise<MutationSuccessResponse>
Success status

takeThreadControl

takeThreadControl(recipientId: string, metadata?: string): Promise<{ success: true }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2895
Takes control of a specific thread from a Secondary Receiver app.
see
https://developers.facebook.com/docs/messenger-platform/reference/handover-protocol/take-thread-control

example
```
await client.takeThreadControl(USER_ID, 'free formed text for another app');
```
Parameters
- recipientId: string
  The PSID of the message recipient.
- Optional metadata: string
  Metadata passed back to the secondary app in the take_thread_control webhook event.
Returns Promise<{ success: true }>
Success status.

typingOff

typingOff(psidOrRecipient: PsidOrRecipient, options?: SenderActionOption): Promise<SendSenderActionResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2262
Turns typing indicators off for the specified user.
see
https://developers.facebook.com/docs/messenger-platform/send-messages/sender-actions#supported_actions

example
```
await client.typingOff(USER_ID);

// Or with persona:
await client.typingOff(USER_ID, { personaId: '<PERSONA_ID>' });
```
Parameters
- psidOrRecipient: PsidOrRecipient
  A facebook page-scoped ID of the recipient or a recipient object
- Optional options: SenderActionOption
  Other optional parameters.
Returns Promise<SendSenderActionResponse>
An object includes recipientId

typingOn

typingOn(psidOrRecipient: PsidOrRecipient, options?: SenderActionOption): Promise<SendSenderActionResponse>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2236
Turns typing indicators on for the specified user.
see
https://developers.facebook.com/docs/messenger-platform/send-messages/sender-actions#supported_actions

example
```
await client.typingOn(USER_ID);

// Or with persona:
await client.typingOn(USER_ID, { personaId: '<PERSONA_ID>' });
```
Parameters
- psidOrRecipient: PsidOrRecipient
  A facebook page-scoped ID of the recipient or a recipient object
- Optional options: SenderActionOption
  Other optional parameters.
Returns Promise<SendSenderActionResponse>
An object includes recipientId

uploadAttachment

uploadAttachment(type: "audio" | "image" | "video" | "file", attachment: string | FileData, options?: UploadOption): Promise<{ attachmentId: string }>

- Defined in messaging-api-messenger/src/MessengerClient.ts:2637
Uploads specified attachment using URL address, buffer, or stream.
see
https://developers.facebook.com/docs/messenger-platform/reference/attachment-upload-api

example
```
await client.uploadAttachment('image', 'http://www.example.com/image.jpg', { isReusable: true });
// { attachmentId: "1857777774821032" }

// Or using read stream:
const fs = require('fs');
await client.uploadAttachment('image', fs.createReadStream('image.jpg'), { isReusable: true });

// Or using buffer:
await client.uploadAttachment('image', buffer, {
  isReusable: true,
  filename: 'image.jpg',
});
```
Parameters
- type: "audio" | "image" | "video" | "file"
  Must be one of image, video, audio or file.
- attachment: string | FileData
  Attachment to be uploaded.
- options: UploadOption = {}
  Other optional parameters.
Returns Promise<{ attachmentId: string }>
An object includes attachment ID

uploadAudio

uploadAudio(attachment: string | FileData, options?: UploadOption): Promise<{ attachmentId: string }>

example

await client.uploadAudio('http://www.example.com/audio.mp3', { isReusable: true });

// Or using read stream:
const fs = require('fs');
await client.uploadAudio(fs.createReadStream('audio.mp3'), { isReusable: true });

// Or using buffer:
await client.uploadAudio(buffer, {
  isReusable: true,
  filename: 'audio.mp3',
});

Parameters

attachment: string | FileData
Optional options: UploadOption
Other optional parameters.

Returns Promise<{ attachmentId: string }>

An object includes attachment ID

uploadFile

uploadFile(attachment: string | FileData, options?: UploadOption): Promise<{ attachmentId: string }>

Uploads file attachment using URL address, buffer, or stream.

example

await client.uploadFile('http://www.example.com/file.pdf', { isReusable: true });

// Or using read stream:
const fs = require('fs');
await client.uploadFile(fs.createReadStream('file.pdf'), { isReusable: true });

// Or using buffer:
await client.uploadFile(buffer, {
  isReusable: true,
  filename: 'file.pdf',
});

Parameters

attachment: string | FileData
Optional options: UploadOption
Other optional parameters.

Returns Promise<{ attachmentId: string }>

An object includes attachment ID

uploadImage

uploadImage(attachment: string | FileData, options?: UploadOption): Promise<{ attachmentId: string }>

Uploads image attachment using URL address, buffer, or stream.

example

await client.uploadImage('http://www.example.com/image.jpg', { isReusable: true });

// Or using read stream:
const fs = require('fs');
await client.uploadImage(fs.createReadStream('image.jpg'), { isReusable: true });

// Or using buffer:
await client.uploadImage(buffer, {
  isReusable: true,
  filename: 'image.jpg',
});

Parameters

attachment: string | FileData
Optional options: UploadOption
Other optional parameters.

Returns Promise<{ attachmentId: string }>

An object includes attachment ID

uploadVideo

uploadVideo(attachment: string | FileData, options?: UploadOption): Promise<{ attachmentId: string }>

Uploads video attachment using URL address, buffer, or stream.

example

await client.uploadVideo('http://www.example.com/video.mp4', { isReusable: true });

// Or using read stream:
const fs = require('fs');
await client.uploadVideo(fs.createReadStream('video.mp4'), { isReusable: true });

// Or using buffer:
await client.uploadVideo(buffer, {
  isReusable: true,
  filename: 'video.mp4',
});

Parameters

attachment: string | FileData
Optional options: UploadOption
Other optional parameters.

Returns Promise<{ attachmentId: string }>

An object includes attachment ID

Static connect

connect(config: ClientConfig): MessengerClient

- Defined in messaging-api-messenger/src/MessengerClient.ts:59
deprecated
Use new MessengerClient(...) instead.

Parameters
- config: ClientConfig
Returns MessengerClient

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

config: ClientConfig

Returns MessengerClient

Properties

Readonly accessToken

Optional Readonly appId

Optional Readonly appSecret

Readonly axios

Readonly version

Methods

associateLabel

Parameters

userId: string

labelId: number

Returns Promise<{ success: true }>

createLabel

Parameters

name: string

Returns Promise<{ id: string }>

createPersona

Parameters

persona: Persona

Returns Promise<{ id: string }>

createSubscription

Parameters

__namedParameters: { accessToken: string; callbackUrl: string; fields?: string[]; includeValues?: boolean; object?: "user" | "page" | "permissions" | "payments"; verifyToken: string }

accessToken: string

callbackUrl: string

Optional fields?: string[]

Optional includeValues?: boolean

Optional object?: "user" | "page" | "permissions" | "payments"

verifyToken: string

Returns Promise<{ success: boolean }>

debugToken

Returns Promise<TokenInfo>

deleteAccountLinkingURL

Returns Promise<MutationSuccessResponse>

deleteGetStarted

Returns Promise<MutationSuccessResponse>

deleteGreeting

Returns Promise<MutationSuccessResponse>

deleteIceBreakers

Returns Promise<MutationSuccessResponse>

deleteLabel

Parameters

labelId: number

Returns Promise<{ success: true }>

deleteMessengerProfile

Parameters

fields: string[]

Returns Promise<MutationSuccessResponse>

deletePersistentMenu

Returns Promise<MutationSuccessResponse>

deletePersona

Parameters

personaId: string

Returns Promise<{ success: true }>

deleteUserPersistentMenu

Parameters

userId: string

Returns Promise<MutationSuccessResponse>

deleteWhitelistedDomains

Returns Promise<MutationSuccessResponse>

disableNLP

Returns Promise<any>

dissociateLabel

Parameters

userId: string

labelId: number

Returns Promise<{ success: true }>

enableNLP

Returns Promise<any>

getAccountLinkingURL