Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/JonathanHerSa/xolo-api-hub/llms.txt

Use this file to discover all available pages before exploring further.

The History screen gives you a chronological record of every request Xolo has sent from the active workspace. Each entry shows the HTTP method, full URL, response status code, duration, and timestamp, so you can review recent activity, spot regressions, and replay any past call in the composer with a single tap. History is workspace-scoped — switching workspaces updates the list automatically. An incognito mode lets you suppress recording for sensitive requests without changing any other behaviour.

​
History Entries

Every successful send (outside of incognito mode) writes a HistoryEntryEntity to local SQLite storage. The entity records the following fields:
FieldDescription
idAuto-incremented entry identifier
methodHTTP verb (e.g. GET, POST)
urlThe fully-resolved URL that was sent (with variables substituted)
originalUrlThe raw URL template before variable substitution
statusCodeHTTP response status code (e.g. 200, 404)
durationMsRound-trip request time in milliseconds
responseBodyThe raw response body string
executedAtUTC DateTime when the request was dispatched
workspaceIdThe workspace the request belongs to
The history list is rendered from recentHistoryStreamProvider, which watches watchRecentHistory(workspaceId) and re-emits whenever a new entry is added or an entry is deleted. Each history card displays the status code in a colour-coded badge (green for 2xx, red otherwise), the HTTP method label in its method colour, the URL truncated to a single line, the human-readable time (e.g. 14:32 for today, Jun 12 for older entries), and the duration in milliseconds.

​
Replaying a Request

Tap any history card to load the request into a new composer tab:
1

Tap the history entry

Tapping a _HistoryItem card triggers _loadHistoryItem, which creates a new tab via tabsProvider.notifier.addTab().
2

Session state is populated

The new tab’s RequestSessionController is seeded with the entry’s method and originalUrl (the un-substituted template, so variables remain editable).
3

Composer opens

The app navigates to the composer (AppRoutes.composer) and activates the new tab. A snackbar confirms “Request loaded in new tab”.

​
Clearing History

1

Tap the sweep icon

Tap the Delete Sweep (🧹) icon in the History screen app bar.
2

Confirm

A confirmation dialog warns that the action cannot be undone. Tap Clear to proceed.
3

History is wiped

clearHistory(workspaceId) removes all entries scoped to the active workspace. To remove history across every workspace at once, call clearAllHistory() from the repository directly.
Individual entries can also be removed by swiping a card from right to left. The dismissal reveals a red delete background; releasing completes the deletion via deleteHistoryEntry(entry). A snackbar with an Undo action appears immediately — tapping it calls restoreHistoryEntry(entry) to reinstate the record.
History is stored locally in SQLite and is not included in cloud sync by default. Clearing history on one device does not affect history on any other device.

​
Incognito Mode

Enable Incognito Mode from the composer toolbar to send requests without recording them in history. While incognito is active:
  • Requests are dispatched and responses are shown normally.
  • The RequestController reads ref.read(isIncognitoProvider) after every send; if the value is true, the addHistoryItem(...) call is skipped entirely.
  • No entry appears in the History screen.
isIncognitoProvider is a NotifierProvider<BooleanNotifier, bool> that defaults to false. BooleanNotifier exposes set(bool) and toggle() to change the value. The provider is not persisted — incognito mode resets to false each time the app starts. 
// incognito_provider.dart
final isIncognitoProvider = NotifierProvider<BooleanNotifier, bool>(
  BooleanNotifier.new,
);

// Inside RequestController.fetchData():
final isIncognito = ref.read(isIncognitoProvider);
if (isIncognito) return; // skip history recording

​
Saved Requests

Requests bookmarked from the composer are stored as SavedRequestEntity records and displayed in the Saved Requests screen (accessible from the Collections tab). Saving calls createRequest(name, method, url, body, collectionId) on XoloRepository, persisting the full request definition including headers, params, body, auth type, auth data, scripts, and assertions. From the Saved Requests screen you can:
  • Open a saved request by tapping it — a new composer tab is opened and pre-populated with the request’s method, URL, body, and name.
  • Delete a saved request via the context menu — softDeleteRequest(id) marks the record as deleted without immediately purging it from storage.
  • Move a request to a different collection via drag-and-drop onto a folder card; the drop calls moveRequest(requestId, collectionId).
  • Browse unclassified requests — requests saved without a collection land in the Unclassified section at the bottom of the screen.

​
Workspace Isolation

Both history and saved requests are scoped to the active workspace. The recentHistoryStreamProvider passes the current activeWorkspaceIdProvider value to watchRecentHistory(workspaceId?): 
final recentHistoryStreamProvider =
    StreamProvider.autoDispose<List<HistoryEntryEntity>>((ref) {
  final repo = ref.watch(xoloRepositoryProvider);
  final workspaceId = ref.watch(activeWorkspaceIdProvider);
  return repo.watchRecentHistory(workspaceId);
});
Passing null as the workspace ID returns history from the global context (no project selected). Switching the active workspace automatically re-subscribes the provider and refreshes the history list.

Build docs developers (and LLMs) love

Get started for freeTalk to us