How to Integrate Retool with Evernote

Navigate to dev.evernote.com and log in with your Evernote account. Click 'Get an API Key' and fill out the application form describing your integration use case. Evernote reviews all API key requests — for internal Retool integrations, explain that you are building an internal admin tool and select 'Full Access' for the requested permissions. Once approved, you receive a consumer key and consumer secret. For a server-side Retool integration where you control both the client and the Evernote account, the most practical approach is to use Evernote's OAuth 1.0a flow in the developer sandbox first, obtain a long-lived access token, and then use the same flow in production. Alternatively, Evernote provides developer tokens for the sandbox environment directly at dev.evernote.com/get-started/testing.php — these are long-lived tokens that work immediately without the full OAuth flow, useful for testing. For production use, complete the full OAuth 1.0a flow: request a temporary token from oauth.evernote.com/oauth, redirect to oauth.evernote.com/OAuth.action for user authorization, then exchange the verifier for a long-lived access token at oauth.evernote.com/oauth. Store the resulting access token — it does not expire unless the user revokes it.

In Retool, navigate to the Resources tab and click 'Create New'. Select 'REST API' from the resource type list. Set the Base URL to 'https://www.evernote.com' for production or 'https://sandbox.evernote.com' for testing — do not include a path, as the specific API path varies by endpoint. Under Authentication, select 'Bearer Token' and enter your OAuth access token value, or add it as a custom header with key 'Authorization' and value 'Bearer YOUR_ACCESS_TOKEN' using '{{ retoolContext.configVars.EVERNOTE_TOKEN }}'. Before saving, go to Retool Settings → Configuration Variables and add 'EVERNOTE_TOKEN' with your OAuth access token, marking it as secret. The Evernote Cloud API uses the path '/edam/note/' as the base for NoteStore operations. Save the resource and verify the connection by creating a simple test query. Note that Evernote's EDAM API is Thrift-based, but many operations are accessible via HTTP POST requests with JSON bodies to the REST-compatible endpoints.

1{
2  "Base URL": "https://www.evernote.com",
3  "Authentication": "Bearer Token",
4  "Headers": {
5    "Authorization": "Bearer {{ retoolContext.configVars.EVERNOTE_TOKEN }}",
6    "Content-Type": "application/json"
7  }
8}

Create a new query using the Evernote resource to fetch all notebooks available to the authenticated user. Use the Evernote Cloud API's NoteStore endpoint. Set the method to GET and the path to '/edam/note/{noteStoreUrl}/NoteStore/listNotebooks' — you first need to retrieve the user's noteStoreUrl from the UserStore. Make an initial GET request to '/edam/user' to get the NoteStore URL for the authenticated account. The response contains a noteStoreUrl field like 'https://www.evernote.com/shard/s1/notestore'. Use this URL as the base for subsequent NoteStore requests. Once you have the NoteStore URL, configure your notebooks query as a GET to the listNotebooks endpoint. The response is an array of notebook objects each containing guid (the unique ID), name, defaultNotebook flag, updateSequenceNum, and serviceUpdated timestamp. Run this query with 'Run when page loads' enabled so the notebook list is available for dropdown filters from the moment the app loads.

1// Step 1: GET /edam/user to retrieve noteStoreUrl
2// This returns user info including the NoteStore URL
3
4// Step 2: GET {noteStoreUrl}/NoteStore/listNotebooks
5// Returns array of notebook objects
6
7// Transformer: format notebooks for Select dropdown
8const notebooks = data || [];
9return notebooks.map(nb => ({
10  label: nb.name,
11  value: nb.guid,
12  is_default: nb.defaultNotebook || false,
13  note_count: nb.stack || 'No stack'
14})).sort((a, b) => a.label.localeCompare(b.label));

Create a query to search notes using Evernote's findNotesMetadata endpoint. This endpoint accepts a NoteFilter object in the request body that supports full-text search via the 'words' field, notebook filtering via 'notebookGuid', tag filtering via 'tagGuids', and date range filtering via 'created' and 'updated' fields (Unix timestamps). The endpoint also accepts 'offset' and 'maxNotes' parameters for pagination. Set the method to POST, the path to '{noteStoreUrl}/NoteStore/findNotesMetadata', and configure the JSON body with a filter object. The response contains a 'notes' array of note metadata objects (not full note content) including guid, title, created, updated, and notebookGuid. To get note content, you need a separate getNoteContent call per note — avoid calling this in a loop for large result sets as it significantly increases API call volume. Add a TextInput component bound to the search filter 'words' parameter, and a Select component bound to 'notebookGuid'. Configure the query to run on component change so search updates dynamically.

1// POST {noteStoreUrl}/NoteStore/findNotesMetadata
2// Body:
3{
4  "filter": {
5    "words": "{{ searchInput.value || '' }}",
6    "notebookGuid": "{{ notebookFilter.value || null }}",
7    "order": 1,
8    "ascending": false
9  },
10  "offset": {{ (pagination.page - 1) * 20 || 0 }},
11  "maxNotes": 20,
12  "resultSpec": {
13    "includeTitle": true,
14    "includeCreated": true,
15    "includeUpdated": true,
16    "includeNotebookGuid": true,
17    "includeTagGuids": true
18  }
19}

Add a JavaScript transformer to the findNotesMetadata query to enrich the results with display-friendly formatting and notebook name lookup. The raw API response includes notebookGuid but not the notebook name — use the notebooks list from your earlier query to create a lookup map. Format dates from Unix timestamps (milliseconds) into readable strings using JavaScript's Date API. Add a Retool Table component bound to the transformer output with columns for title, notebook, last updated, and a hyperlink that opens the note in Evernote using the Evernote deep link format: 'evernote:///view/{userId}/{shardId}/{noteGuid}/{noteGuid}/'. Add a Text component below the Table to display note content when a user clicks a row — trigger a getNoteContent query (GET {noteStoreUrl}/NoteStore/getNoteContent?guid={selectedGuid}) bound to the Table's selectedRow.guid. The content returns as ENML (Evernote Markup Language), which is XML-based — strip tags with a simple regex or render safely in a Text component.

1// Transformer: enrich note metadata with notebook names and formatted dates
2const notes = data && data.notes ? data.notes : [];
3const notebookMap = {};
4(getNotebooks.data || []).forEach(nb => {
5  notebookMap[nb.guid] = nb.name;
6});
7
8return notes.map(note => ({
9  guid: note.guid,
10  title: note.title || 'Untitled',
11  notebook: notebookMap[note.notebookGuid] || 'Unknown Notebook',
12  created: note.created
13    ? new Date(note.created).toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric' })
14    : '',
15  updated: note.updated
16    ? new Date(note.updated).toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric' })
17    : '',
18  days_since_update: note.updated
19    ? Math.floor((Date.now() - note.updated) / 86400000)
20    : null
21}));