The features described in this guide are in Early Access beta, separate from the CRM development tools to build UI extensions with React as frontend beta for private app UI extension development.
Fetching data for public apps (BETA)
While private apps can use serverless functions to fetch data, when you build UI extensions inside public apps, you need to bring your own REST-based back-end and use the hubspot.fetch()
API to fetch data.
Requests made with hubspot.fetch()
are subject to the following limits:
- Each app is allowed up to 20 concurrent requests per account that it's installed in. Additional requests will be rejected with the status code
429
, and can be retried after a delay. - Each request has a maximum timeout of 15 seconds. Both request and response payloads are limited to 1MB. You can specify a lower timeout per request using the
timeout
field. Request duration time includes the time required to establish an HTTP connection. HubSpot will automatically retry a request once if there are issues establishing a connection, or if the request fails with a5XX
status code within the 15 second window.
Below, learn more about using the hubspot.fetch()
API along with examples.
hubspot.fetch()
is as follows:Parameter | Type | Description |
---|---|---|
method
| String | The method to use. |
timeout
| Number | Time in milliseconds to allow for the request to complete before timing out. Timeout will occur when the back-end request duration exceeds this value or 15 seconds—whichever is smaller. Request duration time includes the time required to establish an HTTP connection. HubSpot will retry a request once if there are issues establishing a connection, or if the request fails with a |
body
| Object | The request body. |
hubspot.fetch()
does not support request and response headers. The HubSpot signature must be used to perform authentication/authorization in your back-end. For security reasons, you should not store secrets in your React code to communicate with third-party back-ends. Instead, use your own back-end to fetch data from other third-party APIs after validating the HubSpot signature on the request.
To enable your extension to request data from a URL, you'll first need to add it to the allowedUrls
array in the public-app.json file. URLs not included in this array cannot be requested by the extension.
Please note: when running the local development server, any hubspot.fetch()
request will still go to your hosted back-end via a HubSpot-managed data fetch service, and the request URL must be on the allowlist in public-app.json
. If you need to update the allowlist, you'll need to run hs project upload
for the change to take effect.
To ensure that the requests hitting your back-end are coming from HubSpot, several headers are included in the request. You can use these headers, along with the incoming request fields, to verify the signature of the request. Learn more about validating HubSpot requests.
HubSpot will always populate headers related to request signing and also allow you to pass an Authorization
header from hubspot.fetch()
. See the example hubspot.fetch() request with Authorization header for more information.
Please note: while you can use hubspot.fetch()
to pass an Authorization
request header, hubspot.fetch()
does not pass other client-supplied request headers or return response headers set by your back-end server.
HubSpot also automatically adds the following query parameters to each request to supply metadata: userId
, portalId
, userEmail
, and appId
. As the request URL is hashed as part of the signature header, this will help you securely retrieve the identity of the user making requests to your back-end.
If you're not seeing appended metadata passed with hubspot.fetch()
requests, check whether you have a local.json
file that's currently rerouting requests via a proxy. If so, disable this local data fetch feature by renaming the file to local.json.bak
and restarting the development server.
If you have a locally running back-end, you can set up a proxy to remap hubspot.fetch()
requests made during local development. This proxy is configured through a local.json
file in your project, and will prevent requests from being routed through HubSpot's data fetch service.
To proxy requests to a locally running back-end:
- Create a
local.json
file in the same directory as yourpublic-app.json
file. In this file, define a proxy that remaps requests made usinghubspot.fetch()
. This mapping will only happen for the locally running extension. You can include multiple proxy key-value pairs in theproxy
object.
Please note:
- Each proxy URL must be a valid URL and use HTTPS.
- Path-based routing is not supported. For example, the following proxy won't work:
"https://example.com/a": "http://localhost:8080"
- Upload your project by running
hs project upload
. - With your project uploaded, run
hs project dev
to start the development server. The CLI should confirm that it has detected your proxy. - When you request the mapped URL using
hubspot.fetch()
, the CLI will confirm the remapping.
By default, when proxying requests during local development, requests will not be signed or include metadata in query parameters. However, if you want to introduce request signing into the local development process, you can inject the CLIENT_SECRET
environment variable into the local development process.
After setting up your local.json
file to proxy specific domains, you can inject the CLIENT_SECRET
variable when starting the local development server by prepending the hs project dev
command with the variable:
Note that this doesn't have to be a real CLIENT_SECRET
value, as long as you inject the same variable in your locally running back-end that you're using for hs project dev
. For example, your back-end might include the following Node or Python code:
And to access the CLIENT_SECRET
variable:
Once you've finalized your request signing logic and have permanently added it to your back-end code, you'll need to inject the CLIENT_SECRET
variable from your app into the hs project dev
command permanently. For ease of use, consider baking the variable into your start scripts for local development.
To validate HubSpot request signatures in your custom back-end, check out the request validation guide. You can also use HubSpot's @hubspot/api-client
npm module to verify requests and sign them yourself. For example:
Below are examples of hubspot.fetch
requests to illustrate promise chaining, async/await, and authorization header usage.
You may return a short-lived authorization token from your back-end service after validating the HubSpot signature. You can then use this token to access other resources.
To get the access token from your back-end server in the UI extension:
To return a short-lived access token from your back-end server:
To attach access tokens to other UI extension requests:
Thank you for your feedback, it means a lot to us.