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.
Integration
AI Integration for TherapyNotes

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.
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.
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 /notesto retrieve recent note templates and content for context.POST /notesto create AI-generated draft notes, flagged asdraftstatus for clinician review.GET /assessmentsandPOST /assessmentsfor 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.
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.
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.
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.
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.
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.
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.
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.
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:
- A secure webhook from TherapyNotes notifies your integration service of the new media file attached to the client's chart.
- The service retrieves the file via the TherapyNotes Documents API, sends it to a HIPAA-compliant speech-to-text service, and generates a transcript.
- 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.
- The LLM returns a formatted draft with Subjective, Objective, Assessment, and Plan sections, populated with relevant session details and proposed CPT/ICD-10 codes.
- 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.
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.
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
ProgressNoteAPI endpoint. - Session data from
AppointmentandClientobjects. - 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)
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 / Metric | Before AI Integration | After AI Integration | Implementation & 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. |
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.
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
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:
- 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.
- 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.
- 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" }

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.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us