Write to Fresh Jots from Python — `requests`, `httpx`, or a small SDK

pip install freshjots

from freshjots import Client
Client().append("deploy-log", "deploy ok — sha=abc123")

from freshjots import Client
client = Client()

# 1. Append text to a note — creates it the first time.client.append("cron-jobs-prod", "backup ok")

# 2. Read a note's full plain-text body.print(client.note("cron-jobs-prod")["plain_body"])

# 3. List all your notes (summary projection).for n in client.notes():    print(f"{n['filename']}\t{n['title']}")

# 4. Create a new note explicitly (raises if the filename is taken).client.create("research-2026-q2", body="Initial outline.", title="Q2 Research")

from freshjots import Client, ApiError
client = Client()
try:    
  client.append("huge-note", "x" * 5_000_000)
except ApiError as e:    
  print(f"{e.status} {e.code}: {e}")    
  # 413 content_too_large: body exceeds the per-note 3 MB cap

try:    
  client.append("daily-log", entry)
except ApiError as e: 
  if e.code == "rate_limited": 
    time.sleep(60) 
    client.append("daily-log", entry)     
  elif e.code == "cap_exceeded": 
    # We're at the note count cap — alert ops and drop the line.        
    ops_alert("Fresh Jots cap exceeded; dropping log entry.") 
  else: 
    raise 

client = Client(token="mn_yourrealtokenhere")

client = Client(token="mn_test…", base_url="https://staging.freshjots.com/api/v1")

import os, requests

requests.post(    
  "https://freshjots.com/api/v1/notes/by-filename/deploy-log/append",
  headers={"Authorization": f"Bearer {os.environ['FRESHJOTS_TOKEN']}"},
  json={"text": "deploy ok — sha=abc123"},
  timeout=10,
)

import os
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

session = requests.Session()
session.mount("https://", HTTPAdapter(max_retries=Retry(
  total=3,
  backoff_factor=0.5,
  status_forcelist=[429, 500, 502, 503, 504],
  allowed_methods=["POST"],)))

r = session.post(
  "https://freshjots.com/api/v1/notes/by-filename/deploy-log/append",
  headers={"Authorization": f"Bearer {os.environ['FRESHJOTS_TOKEN']}"},
  json={"text": "deploy ok"},
  timeout=10,
)
r.raise_for_status()

Client().append("deploy-log", "deploy ok")

import os
import httpx

async def append_async(filename: str, text: str, *, timeout: float = 10.0) -> dict:
    token = os.environ["FRESHJOTS_TOKEN"]
    async with httpx.AsyncClient(timeout=timeout) as client:
       r = await client.post(
            f"https://freshjots.com/api/v1/notes/by-filename/{filename}/append",
            headers={"Authorization": f"Bearer {token}"},
            json={"text": text},
        )
        r.raise_for_status()
        return r.json()

import asyncio
import httpx
import os

async def fanout(items: list[tuple[str, str]]) -> list[dict]:
    """items is a list of (filename, text). Returns one response per item."""
    headers = {"Authorization": f"Bearer {os.environ['FRESHJOTS_TOKEN']}"}
    async with httpx.AsyncClient(timeout=10) as client:
        tasks = [
            client.post(
                f"https://freshjots.com/api/v1/notes/by-filename/{name}/append",
                headers=headers,
                json={"text": text},
            )
            for name, text in items
        ]
        responses = await asyncio.gather(*tasks)
        return [r.json() for r in responses if r.is_success]

from contextlib import asynccontextmanager
from fastapi import FastAPI
import httpx

@asynccontextmanager
async def lifespan(app: FastAPI):
    app.state.http = httpx.AsyncClient(timeout=10)
    yield
    await app.state.http.aclose()

app = FastAPI(lifespan=lifespan)

# myapp/middleware.py
from freshjots import Client

_fjots = Client()  # one client per process

class FjotsLogger:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        response = self.get_response(request)
        try:
            _fjots.append(
                "django-requests",
                f"{request.method} {request.path} → {response.status_code}",
            )
        except Exception:
            # Never fail a real request because the log call failed.
            pass
        return response

from fastapi import BackgroundTasks, FastAPI
from freshjots import Client

app = FastAPI()
fjots = Client()

@app.post("/deploy")
async def deploy(payload: dict, background: BackgroundTasks):
    # ... do the deploy ...
    background.add_task(fjots.append, "deploy-log", f"deploy ok — {payload['sha']}")    return {"ok": True}

# celery_base.py
from celery import Task
from freshjots import Client

_fjots = Client()

class FjotsLoggedTask(Task):
    """Base class — every task that inherits writes its summary to a note."""

    def on_success(self, retval, task_id, args, kwargs):
        _fjots.append("celery-jobs", f"{self.name} ok ({task_id})")
    def on_failure(self, exc, task_id, args, kwargs, einfo):
        _fjots.append("celery-failures", f"{self.name} FAILED ({task_id}): {exc}")

# tasks.py

from .celery_base import FjotsLoggedTask
from celery import shared_task

@shared_task(base=FjotsLoggedTask)
def nightly_export():
    ...

import io, sys
from contextlib import redirect_stdout
from freshjots import Client

_fjots = Client()

def jot(note_name: str):
    """Cell decorator. Captures stdout and appends it to a Fresh Jots note."""
    def wrap(fn):
        def inner(*a, **kw):
            buf = io.StringIO()
            with redirect_stdout(buf):
                out = fn(*a, **kw)
            _fjots.append(note_name, buf.getvalue())
            return out
        return inner
    return wrap

@jot("notebook-runs")
def explore():
    print("model accuracy:", 0.91)
    # ... your analysis ...

# conftest.py
import os
import pytest 
from freshjots import Client

@pytest.fixture(scope="session", autouse=True)
def fjots_test_summary():
    yield  # run all tests
    summary = os.environ.get("PYTEST_SUMMARY", "")
    if summary:
        Client().append("test-runs", f"[{os.environ.get('GITHUB_SHA', 'local')}] {summary}")