Inferensys

Integration

AI Integration for TherapyNotes

A technical blueprint for integrating AI into TherapyNotes' core EHR and practice management surfaces, focusing on API-driven workflows for documentation, scheduling, and patient communication to reduce administrative burden for clinicians.
Operations team reviewing AI workflow automation on laptop, workflow builder visible, casual office setup.
A PRACTICAL ARCHITECTURE GUIDE

Where AI Fits into the TherapyNotes Platform

A technical blueprint for connecting AI to TherapyNotes' core EHR surfaces to automate administrative tasks and support clinicians.

The integration surface is defined by TherapyNotes' API and its core data objects. AI workflows typically connect to Client records, Appointments, Progress Notes, Treatment Plans, and Billing/Claims modules. The most impactful automations act on the data flowing through these objects—such as auto-populating a Progress Note from an Appointment encounter or generating a Superbill from a completed note—using the TherapyNotes REST API for secure, bi-directional sync. This API-first approach ensures AI augments the existing workflow without requiring clinicians to leave their primary system.

Implementation follows a secure, event-driven pattern. A middleware layer (often hosted in a compliant cloud like AWS or Azure) listens for webhooks from TherapyNotes for events like note.created or appointment.completed. It then retrieves the relevant PHI via API, processes it through a HIPAA-compliant LLM provider (like Azure OpenAI with a BAA), and posts the structured output—such as a drafted note body or suggested CPT codes—back to the appropriate record. All operations are logged with full audit trails, and a human-in-the-loop review step is enforced before any AI-generated content is committed to the permanent client record.

Rollout is phased by workflow priority. We recommend starting with documentation support (e.g., SOAP note drafting from session templates) to deliver immediate time savings, then expanding to patient communication (automated intake follow-ups) and revenue cycle tasks (claim scrubbing). Each phase involves configuring specific prompts, defining approval gates in the TherapyNotes UI, and training staff on the new, assisted workflow. Governance is maintained through strict access controls tied to TherapyNotes user roles and regular reviews of AI-assisted outputs for clinical accuracy.

API-DRIVEN WORKFLOWS

Key Integration Surfaces in TherapyNotes

Clinical Documentation APIs

TherapyNotes' SOAP/Progress Notes, Treatment Plans, and Clinical Assessments are primary surfaces for AI integration. The API allows for reading existing notes and creating new draft entries.

Key Integration Points:

  • GET /notes to retrieve recent note templates and content for context.
  • POST /notes to create AI-generated draft notes, flagged as draft status for clinician review.
  • GET /assessments and POST /assessments for automated scoring and narrative generation from standardized tools (e.g., PHQ-9, GAD-7).

Implementation Pattern: An AI agent listens for appointment completion webhooks, retrieves the session's scheduled service code and previous note history, generates a structured draft using a clinician-tuned prompt, and posts it back to the chart. This reduces documentation time from 10-15 minutes to 2-3 minutes of review and finalization.

API-DRIVEN WORKFLOWS

High-Value AI Use Cases for TherapyNotes

Integrate AI directly into TherapyNotes' core surfaces to reduce administrative burden, improve clinical quality, and scale practice operations without disrupting therapist workflows.

01

SOAP & Progress Note Generation

Use AI to draft structured clinical notes from session transcripts or therapist dictation, populating the Subjective, Objective, Assessment, Plan (SOAP) sections within the TherapyNotes documentation module. The clinician reviews, edits, and signs off, turning a 15-minute task into a 2-minute review.

15 min -> 2 min
Per note
02

Automated Intake & Onboarding

Connect AI to the Client Portal and Intake Forms. An AI agent can review submitted forms, extract key data (presenting problem, history, PHQ-9 scores), populate the new client record in TherapyNotes, flag urgent risks for clinician review, and send a personalized welcome message—reducing manual data entry to near zero.

Batch -> Real-time
Processing
03

Intelligent Patient Messaging Triage

Deploy a HIPAA-compliant AI agent to monitor the Secure Messaging inbox. It can classify inbound patient messages (e.g., scheduling, billing, clinical question), draft appropriate responses for clinician approval, escalate urgent clinical queries, and log all interactions directly to the client's chart—freeing up front-desk and clinical time.

Same day
Response time
04

CPT/ICD-10 Coding & Claim Scrubbing

Integrate AI with the Billing Module to suggest accurate CPT codes based on note content and session duration, recommend supporting ICD-10 codes, and pre-scrub claims for common errors (e.g., missing modifiers, mismatched diagnoses) before submission. This reduces denials and speeds up revenue cycles.

Reduce denials
Primary impact
05

Treatment Plan Drafting & Review

Leverage AI to generate initial drafts of Treatment Plans by synthesizing intake data, assessment scores, and early session notes. It can suggest measurable goals, evidence-based interventions, and review existing plans for upcoming renewal dates, prompting the clinician for updates.

06

Clinical Decision Support & Risk Flagging

Implement a background AI service that continuously analyzes structured data (e.g., PHQ-9, GAD-7 scores) and unstructured progress notes within the Client Record. It can surface subtle trends, flag potential risk (e.g., elevated suicide indicators) with structured alerts in the clinician's dashboard, and suggest documentation for risk assessment.

Proactive alerts
Workflow shift
THERAPYNOTES INTEGRATION PATTERNS

Example AI-Powered Workflows

These concrete workflows illustrate how AI connects to specific TherapyNotes APIs and surfaces, automating high-volume tasks while keeping the clinician in control. Each pattern is designed for secure, API-driven implementation.

Trigger: Therapist concludes a telehealth session within TherapyNotes and uploads the encrypted audio/video recording.

Workflow:

  1. A secure webhook from TherapyNotes notifies your integration service of the new media file attached to the client's chart.
  2. The service retrieves the file via the TherapyNotes Documents API, sends it to a HIPAA-compliant speech-to-text service, and generates a transcript.
  3. A structured prompt sends the transcript, along with context from the client's previous note (fetched via the Clinical API), to an LLM with instructions to draft a SOAP note.
  4. The LLM returns a formatted draft with Subjective, Objective, Assessment, and Plan sections, populated with relevant session details and proposed CPT/ICD-10 codes.
  5. The draft is posted as an unlocked progress note in the client's chart via the API, flagged for therapist review. The clinician edits, finalizes, and signs the note within the native TherapyNotes interface.

Key Integration Points: TherapyNotes Documents API (upload/retrieve), Clinical API (read/write progress notes), Webhooks for session completion events.

HIPAA-COMPLIANT AI PIPELINE

Implementation Architecture: Data Flow and Guardrails

A secure, API-first architecture for integrating AI into TherapyNotes' clinical and administrative workflows without disrupting existing operations.

A production-ready integration for TherapyNotes is built on its robust REST API, which provides secure access to core objects: Client, Appointment, ProgressNote, TreatmentPlan, and BillingClaim. The primary data flow begins by using API webhooks or scheduled syncs to pull de-identified note drafts, intake form text, or patient message threads into a secure processing queue. This data is then routed through a PHI redaction layer before being sent to a Business Associate Agreement (BAA)-covered LLM provider, such as Azure OpenAI or Google Vertex AI, for processing. The AI's output—a draft SOAP note, a coded claim, or a patient response—is returned to a human-in-the-loop review interface, where a clinician can approve, edit, or reject it before a final API POST or PATCH writes the data back to the correct TherapyNotes record.

Critical guardrails are implemented at each stage. All data in transit and at rest is encrypted. A strict audit trail logs every AI interaction, linking the source client ID, the user who triggered it, the prompt used, and the final action taken. Access is controlled via TherapyNotes' existing role-based permissions—only users with Clinician or Billing Manager roles can initiate or approve AI actions for their assigned clients. For clinical suggestions, the system is designed to be assistive, not autonomous; it never writes directly to a finalized note without explicit review. This architecture ensures compliance with HIPAA and 42 CFR Part 2 while embedding AI directly into the clinician's existing workflow within the TherapyNotes interface.

Rollout follows a phased approach, starting with a single, high-value use case like Progress Note drafting for a pilot group. This allows for tuning prompts against your practice's documentation style and establishing clinician trust. Subsequent phases expand to Intake Form summarization and Patient Message triage, each with its own dedicated review queue and approval workflow. The entire system is monitored for AI drift and operational metrics, ensuring the integration remains a reliable, time-saving tool rather than an administrative burden. For a deeper technical look at grounding AI in your practice's specific data, see our guide on RAG for Behavioral Health EHRs.

API-DRIVEN WORKFLOWS

Code and Payload Examples

SOAP Note Generation via API

This example shows a serverless function that calls an LLM to draft a SOAP note based on session data pulled from the TherapyNotes API. The draft is inserted into a ProgressNote object for clinician review and finalization.

Key Integration Points:

  • TherapyNotes ProgressNote API endpoint.
  • Session data from Appointment and Client objects.
  • Secure, HIPAA-compliant LLM endpoint (e.g., Azure OpenAI with a BAA).

Example Python Payload:

python
# Pseudocode for a Lambda/Cloud Function
def generate_soap_note(appointment_id):
    # 1. Fetch appointment & client data from TherapyNotes
    appointment = therapy_notes_api.get(f'/appointments/{appointment_id}')
    client_id = appointment['clientId']
    client = therapy_notes_api.get(f'/clients/{client_id}')
    
    # 2. Construct prompt with structured data
    prompt = f"""Based on the session, draft a SOAP note.
    Client: {client['firstName']} {client['lastName']}
    Session Date: {appointment['date']}
    Subjective: {appointment.get('notes', '')}
    Objective: Observed mood was {appointment.get('moodRating', 'neutral')}.
    """
    
    # 3. Call LLM (with PHI filtering/logging)
    llm_response = llm_client.chat_completion(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}]
    )
    draft_note = llm_response.choices[0].message.content
    
    # 4. Create draft ProgressNote in TherapyNotes
    note_payload = {
        "clientId": client_id,
        "date": appointment['date'],
        "type": "Progress Note",
        "draftContent": draft_note,
        "status": "Draft"  # Requires clinician sign-off
    }
    therapy_notes_api.post('/progressnotes', json=note_payload)
AI-ASSISTED WORKFLOWS FOR THERAPYNOTES

Realistic Time Savings and Operational Impact

This table illustrates the practical, phased impact of integrating AI into core TherapyNotes surfaces, based on typical implementation patterns for solo and group practices. Metrics focus on reducing manual, repetitive tasks to increase clinician face-to-face time.

Workflow / MetricBefore AI IntegrationAfter AI IntegrationImplementation & Governance Notes

Progress Note (SOAP) Drafting

10-15 minutes per note

3-5 minute review & edit

AI generates initial draft from session audio/transcript or structured inputs; clinician reviews and finalizes. Requires initial prompt tuning.

Intake Form Processing

Manual data entry (20-30 mins)

Automated extraction & record population (5 min review)

AI parses uploaded forms (PDF, scanned) to populate Client Demographics, Insurance, and History. Human verification required for accuracy.

Patient Message Triage

Clinician reviews all messages

AI categorizes & suggests responses for routine inquiries

AI tags messages (e.g., 'scheduling', 'billing', 'clinical follow-up') and drafts templated replies for clinician approval. Critical messages are flagged for immediate review.

CPT/ICD-10 Code Suggestion

Manual lookup and selection

AI suggests codes based on note content

Model analyzes note draft and session duration to propose relevant codes, reducing errors. Final code selection remains with the clinician/biller.

Appointment Reminder & Follow-up

Manual call/email sequences

Automated, personalized message sequences

AI triggers pre/post-appointment messages via client portal based on scheduling data and no-show risk scores. Templates are practice-approved.

Treatment Plan Update Drafting

45-60 minutes per review period

20-30 minutes with AI-generated progress summary

AI synthesizes recent progress notes and outcome scores to draft updated goals and interventions for clinician refinement.

Prior Authorization Document Prep

Gather notes & forms (60+ mins)

AI compiles relevant note excerpts & populates forms (20 min review)

AI retrieves key clinical justification from the EHR to support authorization requests, significantly reducing administrative gather time.

HIPAA, 42 CFR PART 2, AND CONTROLLED ADOPTION

Governance, Compliance, and Phased Rollout

A production AI integration for TherapyNotes requires a security-first architecture and a clinician-led rollout to ensure trust and compliance.

Every integration component—from the API gateway that connects to TherapyNotes' Client, Appointment, and ClinicalNote objects to the LLM service itself—must operate under a Business Associate Agreement (BAA). We architect for PHI minimization, often using de-identified data for training or analysis where possible, and enforce strict access controls that mirror TherapyNotes' own role-based permissions. All AI-generated content is tagged with source data references and written to an immutable audit log alongside the clinician's review actions, creating a clear chain of custody for compliance audits and 42 CFR Part 2 disclosures.

A successful rollout follows a phased, opt-in model. Phase 1 might introduce an AI documentation assistant for a pilot group, generating draft progress notes from session transcripts for clinician review and edit within the TherapyNotes interface. Phase 2 could expand to automated intake summarization, where AI processes new client forms to populate the Client record. Phase 3 might introduce a patient communication agent for routine, scripted check-ins via the client portal. Each phase includes clinician training, clear opt-out controls, and a feedback loop to refine prompts and workflows, ensuring the technology reduces burden without disrupting therapeutic rapport.

Governance is continuous. We implement automated checks for hallucination or off-topic outputs in clinical contexts and establish a review committee of clinicians and compliance officers to evaluate new use cases. This controlled approach allows practices to capture efficiency gains—turning note-writing from a 15-minute task to a 2-minute review—while systematically managing risk and maintaining the human-centered care that is core to behavioral health.

IMPLEMENTATION AND WORKFLOW DETAILS

Frequently Asked Questions

Practical questions and workflow blueprints for integrating AI into TherapyNotes. These answers are based on common technical and operational queries from practice owners, clinical directors, and IT teams.

Connection is established via TherapyNotes' REST API, which provides OAuth 2.0 authentication and granular, scoped permissions. A typical secure architecture involves:

  1. API Gateway & Middleware: An intermediary service (middleware) acts as a secure bridge. It authenticates with TherapyNotes using a service account, fetches the necessary data, and strips Protected Health Information (PHI) or tokenizes it before sending a sanitized context to the AI model.
  2. PHI Handling: For operations requiring PHI (e.g., note generation), you must use a HIPAA-compliant LLM provider (like Azure OpenAI with a BAA) and ensure all data in transit and at rest is encrypted. The middleware should enforce strict data minimization, sending only the fields essential for the task.
  3. Audit Trail: Every API call from the middleware to both TherapyNotes and the AI service should be logged with user ID, timestamp, and action for a complete audit trail.

Example payload sent to an LLM for a progress note draft (with placeholders):

json
{
  "client_context": {
    "presenting_issue": "Generalized Anxiety Disorder",
    "recent_goals": "Practice mindfulness techniques twice daily",
    "last_session_focus": "Cognitive restructuring of catastrophic thinking"
  },
  "session_data": {
    "date": "2024-05-27",
    "duration": 53,
    "modality": "Individual",
    "topics_discussed": ["Work stress", "Sleep patterns", "Application of CBT techniques"]
  },
  "template": "SOAP"
}
Prasad Kumkar

About the author

Prasad Kumkar

CEO & MD, Inference Systems

Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.

His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.