Messenger Platform

 
 
 

Payments (beta)

The Messenger Platform makes it fast, easy, and seamless for you to accept payments from users of your bot. Payments on the Messenger Platform can be implemented in-conversation with the Buy Button, or in the Messenger webview with tokenized payments. This gives you the flexibility to handle user payments in the way that makes the most sense for your bot.

Contents

Payments in Messenger Platform v2.1

The new SDK improves the native payment experience for users in the Messenger webview. Now, people can make a transaction via a webview in Messenger in a single step, as opposed to the previous two-step experience. The integration is easier to implement and will work for both the webview on your 1:1 thread but also in the chat extension. We are deprecating the original SDK over the next 6 months (Feb 1st, 2018).

To view the documentation for the deprecated payments SDK, see Deprecated Webview Payments.

Beta Access

Payments are currently in beta

The feature can be tested by any bot in development mode, if the bot has been accepted into our beta program to receive payments in production.

Request Access →

Integration Options

There are three options for integrating payments into your Messenger bot:


Buy Button (U.S. Only)

The buy button can be sent in a Generic Template or List Template message. The button starts the payment flow, and prompts the message recipient to choose their payment method, shipping address, and other details.

When the message recipient taps the 'Pay' button, the Messenger Platform will automatically complete the transaction using your connected Stripe or Paypal account, or send a tokenized, single-use Discover Card to your webhook for you to process the payment. Once the transaction is completed, details are returned to your webhook.

For implementation steps, see Implementing Payments With the Buy Button or refer to the buy button reference.


Messenger Webview (U.S. Only)

For a custom experience, you can process payments from Messenger users in the Messenger webview, using a connected Stripe/Paypal account or tokenized payments. This gives you complete control of the payment experience. For example, you can integrate your existing checkout page into your customer's Messenger experience.

With this method, you use the Messenger Extensions JavaScript SDK to start the payment flow and prompt your customer for information needed to complete a transaction. The Messenger Platform will automatically complete the transaction using your connected Stripe or Paypal account, or send a tokenized, single-use Discover Card in the payment callback that you can use to process the payment.

For implementation steps, see Implementing Payments With the Messenger Webview.

To view the documentation for the deprecated payments SDK from Messenger Platform v1.2 - 2.0, see Deprecated Webview Payments.


Custom Implementation in the Messenger Webview (Worldwide)

The Messenger Platform provides several ways for you to integrate payments into your Messenger bot with a connected Stripe/Paypal account or tokenized payments, but you are not required to use these integrations. For example, you may already have a checkout flow built into your website that you want to leverage to process payments.

To implement your custom payment flow in Messenger, simply open your existing site in the Messenger webview, and handle your customer's payment as though they were visting your checkout flow on the web.

Please note, that you must apply for permission to offer payments through a custom flow.

For complete details on using the Messenger webview, see the Messenger webview reference.

Supported Payment Providers & Availability

Payment providers are services that process payments for your bot. Currently, we support the following payment providers:

For more on setting up a payment provider, see Getting Started below.

Availability

The following payment providers are available for U.S.-based transactions only:

  • Connected Stripe/Paypal accounts
  • Tokenized payments

Integrations that require international payment processing, or that wish to leverage an existing checkout process, must create a custom implementation in the Messenger webview.


Connected Stripe/Paypal Account

The simplest option for receiving payments is to connect your Stripe or PayPal account to your Facebook Page. Payments with connected Stripe/PayPal accounts can be implemented within a conversation using the buy button, or in the Messenger webview.

With a connected Stripe/PayPal account, Facebook passes the user's payment information and your credentials to the payment provider on your behalf. Once your customer has been successfully charged, the payment will be deposited into your Stripe/PayPal account.

Stripe/PayPal payments have a $0.50 minimum charge.


Tokenized Payments (Custom Provider)

With tokenized payments, the Messenger Platform gives you the option to use the payment provider of your choice. This allows you to integrate Messenger payments into your customized payment flow.

If you are using tokenized payments, when the message recipient clicks 'Pay', the Messenger platform will send you a tokenized, single-use Discover Card that is encrypted with the public key you provide. You can then decrypt the tokenized card and use it to process the payment with your preferred payment provider. The maximum amount you can charge to the tokenized card will be equal to the total that was displayed to the user.

Setting Up a Payment Provider

To get started with implementing payments in Messenger, you will need to set your payment provider. Please note that the Messenger Platform will use the most recently configured payment provider. For example, if you connect your Stripe/PayPal account then upload a public key for tokenized payments, the Messenger Platform will use tokenized payments as your payment provider.

Connected Stripe/PayPal Account

This step is required if you want to process payments using a Stripe or PayPal account connected to your app.

To connect your Stripe or PayPal account, go to the 'Payments' tab in your 'Page Settings'.

When testing integrations with PayPal, the PayPal account you use must be different from the account connected to your Facebook app, otherwise you may encounter an error. To avoid this, modify either your Facebook or PayPal account email address.

Tokenized Payments

To use tokenized payments, you must generate your public key and provide it to the Messenger Platform.

To provide your public key, send a POST request to the Messenger Profile API with the following JSON payload:

{
  "payment_settings" : {
    "public_key" : "<YOUR_PUBLIC_KEY>"
  }
}

Example Request

  curl -X POST -H "Content-Type: application/json" -d '{
  "payment_settings" : {"public_key" : "<YOUR_PUBLIC_KEY>"}
  }' "https://graph.facebook.com/v2.6/me/messenger_profile?access_token=PAGE_ACCESS_TOKEN"

Implementing Payments With the Buy Button

Before you begin, ensure you have set up a payment provider.

  1. Set your payment privacy policy
  2. Regenerate your Page access token
  3. Subscribe to buy button payment webhook events
  4. Send a message with buy button
  5. Handle the messaging_checkout_updates event (Optional)
  6. Handle the messaging_payments event
  7. Respond with a 200 OK

Setting your Payment Privacy Policy URL

For buy button integrations, you must provide a payment privacy URL that Messenger can display to your customer.

To provide your privacy policy URL, send a POST request with the following JSON payload to the Messenger Profile API:

{
  "payment_settings" : {
    "privacy_url" : "<YOUR_PRIVACY_URL>"
  }
}

Example Request

  curl -X POST -H "Content-Type: application/json" -d '{
  "payment_settings" : {"privacy_url" : "www.facebook.com"}
  }' "https://graph.facebook.com/v2.6/me/messenger_profile?access_token=PAGE_ACCESS_TOKEN"

For more, see the Messenger Profile API reference


Regenerating Your Page Access Token

Once your app is accepted into the payments beta program, it will be granted the pages_messaging_payments permission.

Once this permission is granted, you must regenerate your access token in your app's Messenger Settings. This ensures your access token has the correct scopes to make payment-related requests.

For more on generating an access token, see Get a Page Access Token.


Subscribing to Buy Button Webhook Events

To implement buy button payments, you may subscribe your webhook to the following events in the Messenger settings for your app:

  • messaging_payments: Required. Sent to your webhook when the user's payment has been successfully completed.
  • messaging_checkout_updates: Optional. Sent to your webhook after the buy button is clicked. Sends you the customer's shipping information, and expects a response containing shipping options and taxes.
  • messaging_pre_checkouts: Optional. Sent to your webhook after the message recipient clicks the 'Pay' button, but before the payment is processed. This allows you to execute business logic before the payment is actually charged.

Sending a Message With the Buy Button

The buy button can be sent using the generic template or the list template.

To send the buy button, specify type: "payment" and a payment_summary object in the buttons array. After the message recipient clicks the buy button, the Messenger Platform will display a payment dialog.

For more, see the buy button reference.

Example

{
...
  buttons: [{
    "type":"payment",
      "title":"buy",
      "payload":"DEVELOPER_DEFINED_PAYLOAD",
      "payment_summary":{
        "currency":"USD",
        "payment_type":"FIXED_AMOUNT",
        "is_test_payment" : true, 
        "merchant_name":"Peter's Apparel",
        "requested_user_info":[
          "shipping_address",
          "contact_name",
          "contact_phone",
          "contact_email"
        ],
        "price_list":[
          {
            "label":"Subtotal",
            "amount":"29.99"
          },
          {
            "label":"Taxes",
            "amount":"2.47"
          }
        ]
      }
    }
  ]
...
}

Handling the messaging_checkout_updates Event (Optional)

Note that this event will not appear in the Messenger webhook interface until you have been accepted into the beta program.

You must support the messaging_checkout_updates event in your webhook if you are using flexible-amount payments. This callback sends the customer's shipping address to you in the checkout_update property, enabling you to provide them with a list of available shipping options and prices.

{
  "object": "page",
  "entry": [
    {
      "id": "PAGE_ID",
      "time": 1473204787206,
      "messaging": [
        {
          "recipient": {
            "id": "PAGE_ID"
          },
          "timestamp": 1473204787206,
          "sender": {
            "id": "USER_ID"
          },
          "checkout_update": {
            "payload": "DEVELOPER_DEFINED_PAYLOAD",
            "shipping_address": {
              "id": 10105655000959552,
              "country": "US",
              "city": "MENLO PARK",
              "street1": "1 Hacker Way",
              "street2": "",
              "state": "CA",
              "postal_code": "94025"
            }
          }
        }
      ]
    }
  ]
}

You must respond to this event with a 200 OK HTTP status, along with an array of updated shipping options and price details:

{
 "shipping":[
    {
      "option_id":"1", //custom ID
      "option_title":"Fedex", //plain-text description
      "price_list":[
        {
          "label":"Shipping", //label to display
          "amount":5.99 //cost to display
        },
        {
          "label":"Tax",
          "amount":1.99
        }
      ]
    },...  
  ]
}

Once you respond to the event, the Messenger Platform will display an updated checkout summary for the customer to accept.

For more, see the checkout update reference.


Handling the Payment Event

For buy button integrations, payments are handled with the messaging_payments event.

Connected Stripe/Paypal Accounts

After your customer clicks the 'Pay' button, the Messenger Platform will pass the their payment information to Stripe/PayPal on your behalf to complete the charge. On success, the messaging_payments event will be sent to your webhook with customer and payment details, including the Stripe/PayPal charge_id.

Please note that Stripe/PayPal payments have a $0.50 minimum charge.

{
  "object": "page",
  "entry": [
    {
      "id": "PAGE_ID",
      "time": 1473208792799,
      "messaging": [
        {
          "recipient": {
            "id": "PAGE_ID"
          },
          "timestamp": 1473208792799,
          "sender": {
            "id": "USER_ID"
          },
          "payment": {
            "payload": "DEVELOPER_DEFINED_PAYLOAD",
            "requested_user_info": {
              "shipping_address": {
                ...
              },
              "contact_name": "Peter Chang",
              "contact_email": "peter@anemail.com",
              "contact_phone": "+15105551234"
            },
           "payment_credential": {
              "provider_type": "<stripe|paypal>",
              "charge_id": "ch_18tmdBEoNIH3FPJHa60ep123",
              "fb_payment_id": "123456789",
            },      
            "amount": {
              "currency": "USD",
              "amount": "29.62"
            }, 
            "shipping_option_id": "123"
          }
        }
      ]
    }
  ]
}

For more, see the payment callback reference.

Tokenized Payments

After your customer clicks the 'Pay' button, the Messenger Platform will pass their payment information in the messaging_payments event to your webhook. The event will include a tokenized, single-use Discover Card number in the payment_credential object. To complete the payment, decrypt the tokenized card and use it to process the payment:

{
  "object": "page",
  "entry": [
    {
      "id": "PAGE_ID",
      "time": 1473208792799,
      "messaging": [
        {
          "recipient": {
            "id": "PAGE_ID"
          },
          "timestamp": 1473208792799,
          "sender": {
            "id": "USER_ID"
          },
          "payment": {
            "payload": "<DEVELOPER_DEFINED_PAYLOAD>",
            "requested_user_info": {
              "shipping_address": {
                ...
              },
              "contact_name": "Peter Chang",
              "contact_email": "peter@anemailprovider.com",
              "contact_phone": "+15105551234"
            },
            "payment_credential":{
               "provider_type" : "token",
               "tokenized_card": "<TOKENIZED_CARD>",
               "tokenized_cvv":"<TOKENIZED_CVV>",
               "token_expiry_month":"3",
               "token_expiry_year":"2019"
               "fb_payment_id" : "123456789",
            },
            "amount": {
              "currency": "USD",
              "amount": "29.62"
            }, 
            "shipping_option_id": "123"
          }
        }
      ]
    }
  ]
}

For more, see the payment callback reference.


Completing a Buy Button Payment

Once you receive the messaging_payments webhook event and have completed any additional processing, you must return a 200 OK HTTP response to the Messenger Platform to complete the payment process.

Implementing Payments in the Messenger Webview

The API implemented for payments in the Messenger webview mirrors the W3C standard PaymentRequest API.

Before you begin, ensure you have set up a payment provider.

  1. Import Facebook's public PGP key (Tokenized Payments Only)
  2. Include the Messenger Extensions SDK
  3. Initialize a paymentRequest object
  4. Implement event listeners
  5. Verify the payment is supported
  6. Display a button in the webview
  7. Process the payment

Importing Facebook's Public PGP Key (Tokenized Payments Only)

To verify trust in tokenized payments, you must get Facebook's public key and import it into your key ring. Decrypted files from Facebook will be signed and can be verified using our public key.

  1. Download Facebook's public key.
  2. Import the public key into your key ring:
$ gpg -a —import facebook_public.key

Including the Messenger Extensions SDK

To implement payments in Messenger, you must include the Messenger Extensions SDK in the page that is loaded in the Messenger webview.

For a complete walkthrough, see Adding Messenger Extensions.


Initializing a PaymentRequest object

To begin a payment, create an instance of MessengerExtensions.PaymentRequest:

let request = new MessengerExtensions.PaymentRequest(
  methodData, // array of payment methods and their setup
  paymentDetails, // array of items, total, shipping options
  additionalOptions, // request shipping information, payee email address, etc
);

For a detailed list of properties, see the payments webview reference.

methodData Properties

[{
  supportedMethods: ['fb'], //only 'fb' is supported
  data: {
    merchantTitle: 'Merchant name', // optional, defaults to the Facebook Page name
    merchantImageUrl: 'imageURL' //optional, defaults to the app icon
    confirmationText: 'Thank you!' // optional, defaults to "Thank you for your payment"
    merchantFBPageId: 'Merchant Page ID', // page id with onboarded payment method. Need to be the same with the page id in thread or messenger extension
    termsUrl: 'https://www.domain.com/privacy_policy' // Merchant payment privacy terms and conditions.
  }
}]

For a detailed list of properties, see the payments webview reference.

paymentDetails Properties

All payment amount values should satisfy the regular expression ^-?[0-9]+(\.[0-9]+)?$.

{
  displayItems: [ //array of items being charged for
    {
      label: 'T-shirt',
      amount: {
        currency: 'USD',
        value : '15.00'
      }
    },
    ...
  ],
  total: {
    label: 'Total', // defaults to "Total"
    amount: { 
      currency: 'USD', 
      value : '16.23' 
    }
  },
  shippingOptions: [ // Optional. Array of options for user to select
    {
      id: 'free-shipping', // custom ID
      label: 'Free shipping in US', //human-readable name
      amount: {currency: 'USD', value: '0.00'},
      selected: true
    },
    ...
  ]
}

Since it is likely you will not be able to calculate the shipping options until later, when you receive the shipping address, you can omit shippingOptions during the initial PaymentRequest initialization. Instead, handle the shippingaddresschange and shippingoptionchange events. For more, see Implementing Event Listeners.

When shippingOptions is updated, you must also display the option the customer selects in displayItems for the PaymentRequest to be valid.

For a detailed list of properties, see the payments webview reference.

additionalOptions Properties

{
  requestShipping: true, // If shipping is required. If true, handle shippingoptionchange and shippingaddresschange events.
  requestPayerName: false, // Name of the payer sent with the final response
  requestPayerEmail: false, // Email address, same as above
  requestPayerPhone: false // Phone number, same as above
}

For a detailed list of properties, see the payments webview reference.


Implementing Event Listeners

Once you have initialized the PaymentRequest, you can subscribe to various events on the object. The following events are supported:

checkoutcancel (Optional)

request.addEventListener('checkoutcancel', () => {
  // the user has aborted the flow
});

shippingaddresschange

Handling the shippingaddresschange event is required if you set additionalOptions.requestShipping to true when you configured your PaymentRequest.

You can be notified when the person selects an address for shipping. You can then calculate taxes and offer shipping options based on the address.

request.addEventListener('shippingaddresschange', (evt) => {

  evt.updateWith(new Promise(resolve => {  
    const address = request.shippingAddress;
    // calculate shipping costs, update totals...
    resolve(paymentDetails);
  }));
});

When your shippingaddresschange event handler is called, the request object contains the updated shippingAddress property. With this, you must calculate the updated prices, then update the following:

  • paymentDetails.shippingOptions: Update cost of shipping options based on the customer's location
  • paymentDetails.total: Update total cost of items + taxes based on location + shipping
  • paymentDetails.displayItems: Add the selected shipping option and taxes

shippingoptionchange

Handling the shippingoptionchange event is required if you set additionalOptions.requestShipping to true when you configured your PaymentRequest.

The shippingoptionchange event handler is called when your customer selects a shipping option. The request.shippingOption is populated with the id you provided as part of the shipping options configuration.

This handler works the same as shippingaddresschange, it resolves a promise passing the updated paymentDetails.

request.addEventListener('shippingoptionchange', (evt) => {

  evt.updateWith(new Promise(resolve => {  
    const option = request.shippingOption;
    // calculate, e.g.
    // if (request.shippingOption === 'expedited') {
    //   update `paymentDetails`
    // }
    resolve(paymentDetails);
  }));

Verifying the Payment is Supported

Once the request object is created, you can check if it is safe to go forward and display the payment dialog:

request
  .canMakePayment()
  .then((response) => {
    if (response === true) {
      // proceed
    } else {
      // something went wrong, e.g. invalid `displayItems` configuration
      // or the person's phone does not run a 
      // recent enough version of the Facebook app
    }

  })
  .catch((error) => {
    // an error such as `InvalidStateError`
    // if a payment is already in process
  });

Displaying a Button in the Webview

Once you have created an instance of the PaymentRequest object, you need to include a button that your customers can tap to initiate the payment process. The following are some general style guidelines for how the button should look:

  • Button text should be 'Buy Now'
  • Button color should be Messenger blue: #0084ff

Showing the Payments Dialog and Processing the Payment

To show the payment dialog and complete the payment, do the following:

  1. Call request.show() when your button is tapped. The Messenger Platform will present a payment dialog. This method returns a promise.
  2. Handle the returned promise. For tokenized payments, this is when you will charge your customer.
  3. Call complete('success') on the returned object.
request.show().then(paymentResponse => {
  
  // process the payment if using tokenized payments

  paymentResponse.complete('success').then(() => {
    // cleanup UI, log, etc
  });

}).catch(error => console.log(error));

Connected Stripe/PayPal Accounts

For integrations using connected Stripe/PayPal accounts as the payment provider, the resolved promise will return a payment confirmation, including the Stripe/PayPal transaction ID for your records.

Please note that Stripe/PayPal payments have a $0.50 minimum charge.

{
  "paymentRequestID": "f12a99afd3b16ec",
  "methodName": "fb",
  "details": {
    "paymentData": {
      "name": "Michael Knight",
      "amount": "11.23",
      "timestamp": "1500937629",
      "externalTransactionId": "ch_1AjFdrDCVd5339DX6THspfeg"
    },
    "paymentId": "934481639947127",
    "orderData": {
      "totalCurrencyAmount": {
        "amount": "11.23",
        "currency": "USD"
      }
    }
  },
  "shippingAddress": {
    ...
  },
  "shippingOption": "extra",
  "payerName": "",
  "payerEmail": "",
  "payerPhone": ""
}

Tokenized Payments

For integrations using tokenized payments, the resolved promise will return payment details, including a tokenized, single-use Discover Card (tokenCardNumber property) in the returned object. You must decrypt the tokenized card and process the payment before calling complete('success').

{
  "paymentRequestID": "fe319dap33fc8",
  "methodName": "fb",
  "details": {
    "paymentData": {
      "tokenCardNumber": "<TOKENIZED CARD NUMBER>",
      "tokenCvv": "<TOKENIZED CVV NUMBERS>",
      "expirationMonth": "3",
      "expirationYear": "2020",
      "billingAddress": {
        "postalCode": "94036"
      }
    },
    "paymentId": "936416393739001",
    "orderData": {
      "totalCurrencyAmount": {
        "amount": "11.23",
        "currency": "USD"
      }
    }
  },
  "shippingAddress": {
    ...
  },
  "shippingOption": "extra",
  "payerName": "",
  "payerEmail": "",
  "payerPhone": ""
}

Testing Payments (Buy Button Only)

Currently, creating test users for payments is only supported for buy button integrations.

There are two ways to test the end-to-end flow of payments during development without charging real money:

When a test user makes a payment, the Messenger Platform will return a dummy response with the payment flagged as a test payment.

If you have not been accepted to beta program yet, the test payment feature currently only works for tokenized payments.


Adding Test Users with the is_test_payment Property

To test your buy button payment implementation, do the following:

  1. Assign all test users to the 'admin', 'dev', or 'tester' role in the 'Roles' page of your App settings.
  2. Respond to a message from the test user with a buy button that has is_test_payment: true set in its properties.

A dummy charge_id property will be returned in the response payload.

For more, see the buy button reference.


Adding Test Users with the Messenger Profile API

Test users may also be added via a POST request to the Messenger Profile API with the following request body:

{
  "payment_settings":{
    "testers":[<test_user_id_1>, <test_user_id_2>, ...]
  }
}

Payments using the buy button may use the API or the is_test_payment property.

Please refer to the payment webhook event specs and webview extension docs for details.

Example

curl -X POST -H "Content-Type: application/json" -d '{
  "payment_settings":{
    "testers":[
      12345678
    ]
  }
}' "https://graph.facebook.com/v2.6/me/messenger_profile?access_token=PAGE_ACCESS_TOKEN"

Generating an Encryption Key

You may set a payment public key to encrypt sensitive data that is sent to you. This is only required for payments initiated from the webview and buy button if you are receiving tokenized payments.

The following example uses GNU Privacy Guard.

1. Generate your key with RSA, 4096 bits, non-expiring. Note output which contains the Key ID

$ gpg --gen-key

...

gpg: key [KEY_ID] marked as ultimately trusted
public and secret key created and signed.

2. Export your public key with armor

$ gpg —armor —export [KEY_ID] > public.key

3. Format the key

So that you can set it using the Messenger Profile API, replace newlines with "\n"

$ perl -p -e 's#\n#\\n#g' public.key > escaped_key.txt

Decrypting Tokenized Payment Data

In some cases, sensitive data is encrypted when transmitted. For tokenized payments in buy button and Messenger webview integrations, we encrypt data using your public key.

Example: The response to completing a payment using the Messenger Extensions SDK:

{
"payment_result":"-----BEGIN PGP MESSAGE-----\n\nhQIMA6FrXqi2gpwjAQ/7BvmxbMQRmrVhKCzauTPaub3ySabTP+pxg8\n=aYwc\n-----END PGP MESSAGE-----\n"
}

1. Get the encrypted value (armor and data) from the response.

-----BEGIN PGP MESSAGE-----\n\nhQIMA6FrXqi2gpwjAQ/7BvmxbMQRmrVhKCzauTPaub3ySabTP+pxg8\n=aYwc\n-----END PGP MESSAGE-----\n

2. You may have to format the encrypted response by replacing "\n" with newlines.

$ perl -pi -e 's#\\n#\n#g' encrypted_value.gpg

3. Call gpg to decrypt.

$ gpg -d encrypted_value.gpg

Notes on GPG Decryption

When using the GPG program from the command line, it may be difficult to see the decrypted content because it is interleaved with the output. In the example below, the decrypted content is "ch_18to0LEoNIH3FPJH5YJ61hup".

$ gpg -d response.gpg
You need a passphrase to unlock the secret key for
user: "Alyssa P. Hacker <hacker@hack.com>"
4096-bit RSA key, ID B1234C11, created 2016-09-14 (main key ID 1ABC23D4)

gpg: encrypted with 4096-bit RSA key, ID B1234C11, created 2016-09-14
"Alyssa P. Hacker <hacker@hack.com>"
ch_18to0LEoNIH3FPJH5YJ61hupgpg: Signature made Wed Sep 14 17:45:32 2016 PDT using RSA key ID 71824565
gpg: Good signature from "Facebook, Inc."

Notes on GPG Trust

During decryption, you may get a warning about the key not being certified. You can read more about validating trust in your key ring.

gpg: Signature made Wed Sep 14 17:45:32 2016 PDT using RSA key ID 12345678
gpg: Good signature from "Facebook, Inc."
gpg: WARNING: This key is not certified with a trusted signature!
gpg: There is no indication that the signature belongs to the owner.
Primary key fingerprint: 41B8 0953 E4A2 90BA 28A7 3776 2F38 12D3 DEE9 BC32

Support for Deprecated Versions

As of July 27, 2017, the implementation and usage of webview payments from Messenger Platform versions v1.2 - v2.0 are deprecated. Support for the deprecated usage will continue until February 1, 2018.

All integrations for payments in the Messenger webview, using the Messenger Extensions SDK should migrate to the usage described in this document.

The documentation for the deprecated usage, can be found here:

Getting Help

Visit our Help Center for more information about payments in Messenger.