# OpenHuman 20-Minute Sync Integrations: How to Configure Auto-Fetch Intervals

> Discover OpenHuman integrations supporting 20-minute sync. Learn to configure auto-fetch intervals easily in Settings to streamline your data synchronization.

- Repository: [Tiny Humans/openhuman](https://github.com/tinyhumansai/openhuman)
- Tags: how-to-guide
- Published: 2026-06-16

---

**OpenHuman's auto-fetch scheduler synchronizes all native provider integrations every 20 minutes, with per-connection toggles available in Settings → Integrations to enable or disable automatic syncing.**

The `tinyhumansai/openhuman` repository maintains a continuous **20-minute sync** cycle that automatically pulls fresh data from connected services into your Memory Tree. This fixed-interval **auto-fetch** system applies universally to all integrations shipping a native Rust provider, ensuring your knowledge base stays current without manual intervention.

## Which Integrations Support 20-Minute Sync

All integrations that ship a **native provider**—a Rust module that knows how to ingest the service—participate in the 20-minute auto-fetch schedule. According to the integrations catalog in [`gitbooks/features/integrations/README.md`](https://github.com/tinyhumansai/openhuman/blob/main/gitbooks/features/integrations/README.md), the following categories and services are supported:

### Email, Calendar, and Productivity

- **Email & Calendar**: Gmail, Outlook, Google Calendar, Apple Calendar
- **Productivity Tools**: Notion, Todoist, Asana, ClickUp

### Development and Communication Platforms

- **Code & Dev**: GitHub, GitLab, Bitbucket
- **Communication**: Slack, Discord, Microsoft Teams, Telegram, WhatsApp, Signal, Matrix

### Storage, Finance, and Project Tracking

- **File & Drive**: Google Drive, Dropbox, OneDrive
- **Payments & Finance**: Stripe, PayPal
- **Issue & Project Tracking**: Linear, Jira, Trello, ClickUp

The actual provider implementations reside in `src/openhuman/memory_sync/composio/providers/**/*.rs`, where each Rust module handles the ingestion logic for its respective service. Registration of these adapters and their auto-fetch capabilities is managed in [`src/openhuman/integrations/mod.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/integrations/mod.rs).

## How to Configure Auto-Fetch Intervals

The **20-minute interval is fixed** and cannot be customized per-integration. However, you control whether individual connections participate in this schedule.

### Enabling Auto-Fetch via the UI

To activate the 20-minute sync for a specific connection:

1. Navigate to **Settings → Integrations**
2. Select your desired service and click **Connect** to complete the OAuth flow
3. Once connected, toggle the **"Auto-fetch"** switch to ON

This adds the connection to the scheduler's loop defined in [`src/openhuman/scheduler/mod.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/scheduler/mod.rs). To pause syncing, return to the same Settings screen and disable the toggle.

### Programmatic Control with JSON-RPC

For advanced automation, the core exposes the `integration.toggle_auto_fetch` method. This JSON-RPC endpoint accepts a connection ID and boolean flag:

```json
{
  "jsonrpc": "2.0",
  "method": "integration.toggle_auto_fetch",
  "params": {
    "connection_id": "gmail-12345",
    "enabled": true
  },
  "id": 1
}

```

Set `"enabled": false` to remove the connection from the 20-minute rotation without deleting the integration.

### Verifying Scheduler Status

Confirm the scheduler is actively processing the 20-minute tick by querying the health endpoint:

```bash
curl http://127.0.0.1:8000/health | jq .scheduler

```

The response includes a `next_tick` timestamp indicating the next 20-minute interval and a list of connections queued for auto-fetch.

## Technical Implementation Details

The auto-fetch mechanism is documented in [`gitbooks/features/obsidian-wiki/auto-fetch.md`](https://github.com/tinyhumansai/openhuman/blob/main/gitbooks/features/obsidian-wiki/auto-fetch.md), which describes how the scheduler triggers a tick every twenty minutes and walks all active connections. The scheduler core in [`src/openhuman/scheduler/mod.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/scheduler/mod.rs) maintains this cadence, while individual provider implementations in `src/openhuman/memory_sync/composio/providers/**/*.rs` execute the actual data ingestion into the Memory Tree.

## Summary

- **All native providers** participate in OpenHuman's fixed **20-minute sync** cycle, including Gmail, Slack, GitHub, Notion, and Google Drive
- The **auto-fetch interval is hardcoded at 20 minutes** and cannot be adjusted per-integration
- Enable or disable syncing per connection via the **Settings → Integrations** UI toggle or the **`integration.toggle_auto_fetch`** JSON-RPC method
- Monitor scheduler health using the **`/health`** endpoint to verify the next 20-minute tick is scheduled

## Frequently Asked Questions

### Can I change the 20-minute auto-fetch interval?

No. The 20-minute interval is fixed in the scheduler core at [`src/openhuman/scheduler/mod.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/scheduler/mod.rs) and applies universally to all native provider integrations. You cannot configure custom intervals for individual connections.

### How do I know if an integration supports automatic syncing?

Check the integrations catalog at [`gitbooks/features/integrations/README.md`](https://github.com/tinyhumansai/openhuman/blob/main/gitbooks/features/integrations/README.md). Any service listed there with a native Rust provider in `src/openhuman/memory_sync/composio/providers/` supports the 20-minute auto-fetch. Third-party integrations without native providers do not participate in the automatic schedule.

### What happens when I disable auto-fetch for a connection?

Disabling auto-fetch removes the connection from the scheduler's 20-minute loop immediately. The connection remains authenticated and available for manual syncs, but the system will no longer automatically pull fresh data every twenty minutes until you re-enable the toggle.

### How can I verify the scheduler is running correctly?

Query the health endpoint at `http://127.0.0.1:8000/health` and inspect the `scheduler` object in the JSON response. A healthy system returns a `next_tick` timestamp exactly 20 minutes from the last execution and lists all connections currently enrolled in auto-fetch.