# How to Integrate Everyone-Can-Use-English with Other Tools: A Complete Integration Guide

> Learn how to integrate Everyone-Can-Use-English with other tools using our comprehensive guide. Explore API clients, provider modules, and more for seamless integration.

- Repository: [Zuodao/everyone-can-use-english](https://github.com/ZuodaoTech/everyone-can-use-english)
- Tags: how-to-guide
- Published: 2026-08-14

---

**Integrate Everyone-Can-Use-English (ECUE) via its API client, provider modules, database handlers, WebSocket channels, or reusable Node utilities to embed it as a library, call services from servers, or wire into broader workflows.**

Everyone-Can-Use-English is a modular Electron application built with **Vite**, **TypeScript**, and **SQLite**. Understanding how to integrate everyone-can-use-english with other tools opens up possibilities for building custom language-learning platforms, transcription pipelines, or LLM-powered assistants. This guide covers every integration point with runnable code examples from the ZuodaoTech/everyone-can-use-english source code.

## Integration Architecture Overview

ECUE separates concerns into three distinct layers that external tools can tap into:

| Layer | Purpose | Key File |
|-------|---------|----------|
| **Renderer** | React-based UI communicating via IPC | [`enjoy/src/renderer.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/renderer.ts) |
| **Preload** | Secure Node API bridge to renderer | [`enjoy/src/preload.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/preload.ts) |
| **Main** | Core logic, filesystem, database, external services | [`enjoy/src/main.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/main.ts) |

External integration happens through well-defined boundaries in the **main process layer**, where Node.js capabilities remain fully available.

## Integration Method 1: API Client for HTTP-Style Communication

The `ApiClient` class in [`enjoy/src/api/client.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/api/client.ts) provides a thin wrapper around ECUE's internal endpoints. This is the cleanest way to integrate everyone-can-use-english with other tools when you need high-level operations like creating recordings or fetching transcriptions.

```typescript
// example-integration.ts
import { ApiClient } from 'path/to/everyone-can-use-english/enjoy/src/api/client';

const client = new ApiClient({ baseURL: 'http://localhost:3000/api' });

async function createRecording(videoUrl: string) {
  const resp = await client.post('/recordings', { url: videoUrl });
  console.log('Recording created:', resp.data);
}

createRecording('https://www.youtube.com/watch?v=abc123');

```

The client reads the same configuration as the main application, ensuring consistent behavior across external calls.

## Integration Method 2: Provider Modules for Media Extraction

Provider modules in `enjoy/src/main/providers/*.ts` expose a standardized `fetchResources` API. These plug-in-style modules handle YouTube, TED, Audible, and other sources—perfect for batch processing or server-side media pipelines.

```typescript
import { YoutubeProvider } from 'path/to/everyone-can-use-english/enjoy/src/main/providers/youtube-provider';

async function getMeta(id: string) {
  const provider = new YoutubeProvider();
  const meta = await provider.fetchResources({ 
    url: `https://www.youtube.com/watch?v=${id}` 
  });
  console.log(meta);
}

getMeta('abc123');

```

Additional providers follow the same pattern:
- **TED** — [`enjoy/src/main/providers/ted-provider.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/main/providers/ted-provider.ts)
- **Audible** — [`enjoy/src/main/providers/audible-provider.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/main/providers/audible-provider.ts)

Each returns normalized metadata including subtitles, audio URLs, and duration information.

## Integration Method 3: Database Handlers for Direct Data Access

For low-level operations, import the SQLite connection from [`enjoy/src/main/db/index.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/main/db/index.ts) or use specific handlers in `enjoy/src/main/db/handlers/*.ts`.

```typescript
import { db } from 'path/to/everyone-can-use-english/enjoy/src/main/db';

async function countCompletedRecordings() {
  const rows = await db.all(
    'SELECT COUNT(*) AS cnt FROM recordings WHERE status = ?', 
    ['completed']
  );
  console.log('Completed recordings:', rows[0].cnt);
}

countCompletedRecordings();

```

Domain-specific handlers like [`recordings-handler.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/recordings-handler.ts) encapsulate CRUD logic and validation, making them safer than raw SQL for most use cases.

## Integration Method 4: WebSocket Channels for Real-Time Events

The cable system in [`enjoy/src/renderer/cables/channels/notifications_channel.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/renderer/cables/channels/notifications_channel.ts) broadcasts transcription progress, completion events, and other updates.

```typescript
import { NotificationChannel } from 'path/to/everyone-can-use-english/enjoy/src/renderer/cables/channels/notifications_channel';

const channel = new NotificationChannel('ws://localhost:3000/cable');
channel.on('transcription-progress', (payload) => {
  console.log('Progress:', payload.percentComplete);
});

```

Subscribe to these channels from external services to trigger downstream workflows without polling.

## Integration Method 5: Reusable Node Utilities for Automation

Two standalone modules enable headless automation and CI integration:

- **[`enjoy/src/main/proxy-agent.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/main/proxy-agent.ts)** — Configurable HTTP/HTTPS proxy handling
- **[`enjoy/src/main/downloader.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/main/downloader.ts)** — Batch audio/video download orchestration

Import these directly in Node scripts to build automated pipelines:

```typescript
import { Downloader } from 'path/to/everyone-can-use-english/enjoy/src/main/downloader';

const dl = new Downloader({ concurrency: 4 });
await dl.queueBatch(urlList, {
  onComplete: (file) => uploadToS3(file),
  onError: (err) => logToMonitoring(err)
});

```

## Key Integration Files Reference

| File | Integration Purpose |
|------|---------------------|
| [`enjoy/src/api/client.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/api/client.ts) | HTTP-style API wrapper |
| [`enjoy/src/api/index.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/api/index.ts) | API utilities export barrel |
| [`enjoy/src/main/db/index.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/main/db/index.ts) | Central SQLite connection |
| [`enjoy/src/main/db/handlers/recordings-handler.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/main/db/handlers/recordings-handler.ts) | Recording CRUD operations |
| [`enjoy/src/main/providers/youtube-provider.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/main/providers/youtube-provider.ts) | YouTube metadata extraction |
| [`enjoy/src/main/providers/ted-provider.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/main/providers/ted-provider.ts) | TED talk processing |
| [`enjoy/src/renderer/cables/channels/notifications_channel.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/renderer/cables/channels/notifications_channel.ts) | Real-time event subscription |
| [`enjoy/src/main/downloader.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/main/downloader.ts) | Batch download automation |
| [`enjoy/src/main/proxy-agent.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/main/proxy-agent.ts) | Proxy configuration utility |

## Choosing the Right Integration Approach

- **Use the API client** when you need stability and don't want to manage database connections
- **Use provider modules** for media-focused workflows independent of ECUE's storage
- **Use database handlers** for analytics, migrations, or data synchronization tasks
- **Use WebSocket channels** when real-time responsiveness matters
- **Use downloader/proxy utilities** for automation and batch processing

Multiple approaches can be combined. For example, trigger recordings via the API client, monitor progress through WebSocket channels, then query completed results through database handlers.

## Summary

- ECUE exposes five primary integration surfaces: **API client**, **provider modules**, **database handlers**, **WebSocket channels**, and **reusable Node utilities**
- All integration points live in the main process layer with full Node.js capability
- The `ApiClient` class ([`enjoy/src/api/client.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/api/client.ts)) provides the most stable external interface
- Provider modules offer plug-and-play media extraction from YouTube, TED, and other sources
- Direct database access through [`enjoy/src/main/db/index.ts`](https://github.com/ZuodaoTech/everyone-can-use-english/blob/main/enjoy/src/main/db/index.ts) enables custom analytics and data pipelines
- Real-time integration is possible via the notification channel system in `enjoy/src/renderer/cables/`

## Frequently Asked Questions

### Can I run ECUE integrations without launching the full desktop application?

Yes. The provider modules, database handlers, and downloader utilities are pure Node.js code with no Electron dependencies. Import them directly in server-side scripts or CLI tools. Only the renderer process and WebSocket channels require the full application to be running.

### What authentication is required for external API calls?

The `ApiClient` reads configuration from the same sources as the main application, including any bearer tokens or API keys stored in ECUE's settings. For direct database access, standard SQLite file permissions apply—ensure your external process has filesystem access to the ECUE data directory.

### How do I handle schema changes when integrating directly with the SQLite database?

Database handlers in `enjoy/src/main/db/handlers/*.ts` abstract schema details and include migration logic. Import and use these handlers rather than writing raw SQL when possible. For custom queries, monitor the handler source files for schema updates between ECUE releases.

### Are there rate limits or concurrency constraints on provider modules?

Individual providers implement their own throttling. The `YoutubeProvider` includes built-in delays and retry logic to respect service terms. The `Downloader` utility accepts a `concurrency` option to control parallel requests. Review each provider's implementation in `enjoy/src/main/providers/` for specific limits.