Facebook Pages (Edge)

You can connect Hevo to your Facebook Pages account with an OAuth app created in your developer account. This method is available only through the Hevo API. Specify the credentials of the app in the request that creates the Pipeline, and Hevo uses them to authenticate with your account.

The following credentials from your OAuth app are required to authenticate the connection:

• Client ID: The App ID of your Meta app. Meta displays it on the app dashboard, and names it App ID in the UI and client_id in the API.

• Client Secret: The App Secret of your Meta app. Hevo sends it with the App ID to authenticate the request. Meta names it App Secret in the UI and client_secret in the API.

• Access Token: A long-lived user access token that your app receives when a Facebook user authorizes it. Meta issues no refresh token for this flow, so Hevo uses the long-lived token and renews it from Meta.

Create the app in your Meta developer account and grant it the permissions required for the Pages you want to replicate. Read Create an app with Meta for the steps to create the app, and Get a long-lived user access token for the steps to exchange a short-lived token for the long-lived one.

Grant the app the following permissions:

Prepare the Source Configuration

Before you build your request, retrieve the settings that the Facebook Pages connector currently accepts. Refer to Read the Connector Configuration for the steps to retrieve them.

In the response, the auth object describes the credentials of your own OAuth app. In the connector configuration response, Hevo returns the auth object under data.schema.properties.auth, and the connector settings under data.schema.properties.config. Only a connector that accepts an OAuth app has an auth property. Each credential carries "type": "string". Every credential except client_id also carries "format": "password" and "writeOnly": true. The following example shows part of the auth object:

{
  "auth": {
    "required": [
      "client_access"
    ],
    "properties": {
      "client_access": {
        "required": [
          "client_id",
          "client_secret"
        ],
        "properties": {
          "client_id": {
            "title": "Client ID"
          },
          "client_secret": {
            "title": "Client Secret"
          }
        }
      },
      "refresh_token": {
        "title": "Refresh Token"
      },
      "access_token": {
        "title": "Access Token"
      }
    },
    "anyOf": [
      {
        "required": [
          "refresh_token"
        ]
      },
      {
        "required": [
          "access_token"
        ]
      }
    ]
  }
}

Leave config.auth_method blank, or set it to GRANT_USER_ACCESS. To sync only some Pages, set config.sync_mode to SPECIFIC_PAGES and list the Page IDs as strings in config.selected_pages, such as ["123456789012345"]. With SPECIFIC_PAGES and an empty list, Hevo syncs every Page. A Page that your token cannot access is skipped with a warning, and the Source fails only when none of the Pages you selected can be accessed.

Specify the credentials of your app in the auth object. Use sync_mode to control which Pages Hevo replicates. Specify ALL_PAGES to replicate every Page your app can access, or SPECIFIC_PAGES to choose them yourself. Default value: ALL_PAGES. The following example shows the source object for a Facebook Pages Source:

{
  "name": "<source_name>",
  "connector_id": "facebook_pages",
  "type": "FACEBOOK_PAGES",
  "config": {
    "sync_mode": "ALL_PAGES"
  },
  "auth": {
    "client_access": {
      "client_id": "<client_id>",
      "client_secret": "<client_secret>"
    },
    "access_token": "<access_token>"
  }
}

Note: Replace the placeholder values in the example with your own. For example, <source_name> with My Facebook Pages Account.

Specify this source object in the request that creates your Pipeline. Read Creating a Pipeline with Hevo API for the complete request and the remaining steps.

Hevo validates the credentials and tests the Source and Destination connections before it saves anything. To test the Source connection, Hevo uses the credentials in the auth object to generate an access token. If a credential is rejected or a test fails, the request returns an error, and no Pipeline is created. Hevo also deletes the access token that it generated.

Note: Hevo does not store these credentials in the Source configuration. It exchanges them for an authorization when the Pipeline is created, so the Source is set up without a browser sign-in. Hevo does not return them if you retrieve the Source configuration later. If you revoke the credentials in Meta, Hevo cannot authenticate with the Source. As a result, all active jobs for the Pipeline fail, and no data is replicated. To resume data replication, send the new credentials using the Modify Source Configuration in a Pipeline endpoint. Read Modifying the Source Configuration for the steps to send them.