How to Integrate Replit with Evernote

1# Python — install Evernote SDK
2# Run in Replit Shell:
3# pip install evernote3
4# Or add to requirements.txt:
5# evernote3>=1.28.0
6
7# For Node.js, run in Replit Shell:
8# npm install evernote
9
10# Verify installed:
11import pkg_resources
12try:
13    pkg_resources.get_distribution('evernote3')
14    print('Evernote SDK installed successfully')
15except pkg_resources.DistributionNotFound:
16    print('Run: pip install evernote3')

1# Python — Evernote OAuth 1.0a flow (oauth_setup.py)
2from flask import Flask, request, redirect
3import os
4from evernote.api.client import EvernoteClient
5
6app = Flask(__name__)
7
8CONSUMER_KEY = os.environ['EVERNOTE_CONSUMER_KEY']
9CONSUMER_SECRET = os.environ['EVERNOTE_CONSUMER_SECRET']
10SANDBOX = os.environ.get('EVERNOTE_SANDBOX', 'true').lower() == 'true'
11
12# Replace with your Replit preview or deployment URL
13CALLBACK_URL = os.environ.get('REPLIT_URL', 'http://localhost:3000') + '/oauth/callback'
14
15client = EvernoteClient(consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET, sandbox=SANDBOX)
16
17@app.route('/oauth/start')
18def oauth_start():
19    request_token = client.get_request_token(CALLBACK_URL)
20    # Store oauth_token temporarily (in production use a session or DB)
21    app.config['REQUEST_TOKEN'] = request_token
22    authorize_url = client.get_authorize_url(request_token)
23    return redirect(authorize_url)
24
25@app.route('/oauth/callback')
26def oauth_callback():
27    oauth_token = request.args.get('oauth_token')
28    oauth_verifier = request.args.get('oauth_verifier')
29    request_token = app.config.get('REQUEST_TOKEN', {})
30    access_token = client.get_access_token(
31        request_token.get('oauth_token'),
32        request_token.get('oauth_token_secret'),
33        oauth_verifier
34    )
35    # COPY THIS TOKEN TO REPLIT SECRETS AS EVERNOTE_ACCESS_TOKEN
36    print(f"ACCESS TOKEN: {access_token}")
37    return f"Access token obtained. Copy it to Replit Secrets: {access_token}"
38
39if __name__ == '__main__':
40    app.run(host='0.0.0.0', port=3000)

1// Node.js — verify Evernote secrets (verify-secrets.js)
2const required = ['EVERNOTE_CONSUMER_KEY', 'EVERNOTE_CONSUMER_SECRET', 'EVERNOTE_ACCESS_TOKEN'];
3for (const key of required) {
4  const val = process.env[key];
5  if (!val) {
6    console.error(`MISSING: ${key} — add it in Replit Secrets (lock icon 🔒)`);
7    process.exit(1);
8  }
9  console.log(`OK: ${key} loaded (${val.length} chars)`);
10}
11console.log('All Evernote secrets verified.');

1# Python — read notebooks and create a note (evernote_client.py)
2import os
3from evernote.api.client import EvernoteClient
4from evernote.edam.type.ttypes import Note
5
6ACCESS_TOKEN = os.environ['EVERNOTE_ACCESS_TOKEN']
7SANDBOX = os.environ.get('EVERNOTE_SANDBOX', 'true').lower() == 'true'
8
9client = EvernoteClient(token=ACCESS_TOKEN, sandbox=SANDBOX)
10note_store = client.get_note_store()
11
12# List all notebooks
13notebooks = note_store.listNotebooks()
14print("Your notebooks:")
15for nb in notebooks:
16    print(f"  {nb.name} (GUID: {nb.guid})")
17
18# Create a simple note
19def create_note(title, plain_text, notebook_guid=None):
20    enml_content = (
21        '<?xml version="1.0" encoding="UTF-8"?>'
22        '<!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">'
23        f'<en-note><p>{plain_text}</p></en-note>'
24    )
25    note = Note()
26    note.title = title
27    note.content = enml_content
28    if notebook_guid:
29        note.notebookGuid = notebook_guid
30    created = note_store.createNote(note)
31    print(f"Created note: {created.title} (GUID: {created.guid})")
32    return created
33
34# Create a test note in the first available notebook
35if notebooks:
36    create_note("Replit Test Note", "This note was created from Replit!", notebooks[0].guid)

1// Node.js — Evernote search endpoint (search.js)
2const Evernote = require('evernote');
3const express = require('express');
4
5const app = express();
6app.use(express.json());
7
8const ACCESS_TOKEN = process.env.EVERNOTE_ACCESS_TOKEN;
9const SANDBOX = process.env.EVERNOTE_SANDBOX === 'true';
10
11const client = new Evernote.Client({ token: ACCESS_TOKEN, sandbox: SANDBOX });
12
13app.get('/search', async (req, res) => {
14  const query = req.query.q;
15  if (!query) return res.status(400).json({ error: 'q parameter required' });
16  try {
17    const noteStore = await client.getNoteStore();
18    const filter = new Evernote.Types.NoteFilter({ words: query });
19    const spec = new Evernote.NoteStore.NotesMetadataResultSpec({
20      includeTitle: true,
21      includeNotebookGuid: true,
22      includeCreated: true
23    });
24    const result = await noteStore.findNotesMetadata(filter, 0, 10, spec);
25    const notes = result.notes.map(n => ({
26      guid: n.guid,
27      title: n.title,
28      notebook: n.notebookGuid,
29      created: new Date(n.created).toISOString()
30    }));
31    res.json({ query, count: notes.length, notes });
32  } catch (err) {
33    console.error('Evernote search error:', err);
34    res.status(500).json({ error: err.message });
35  }
36});
37
38app.listen(3000, '0.0.0.0', () => console.log('Evernote search API running'));