Outlook

Microsoft requires either an App Password or OAuth2 XOAUTH2 for IMAP/SMTP access — standard username and password login no longer works. App Passwords are the simpler option for a FlutterFlow integration and are available when your Microsoft account has two-factor authentication (MFA) enabled. Open a browser and go to account.microsoft.com/security. Sign in with the Outlook account you want to use. Click 'Advanced security options' (you may need to scroll down). Under 'App passwords', click 'Create a new app password'. Microsoft will generate a 16-character password like `abcd efgh ijkl mnop` — copy it immediately because it's only shown once. You'll use this string in your Dart custom action instead of your normal Outlook password. If you don't see the App Passwords option, it means MFA is not yet enabled on your account. Scroll up to 'Two-step verification' and follow the prompts to enable it (takes about 3 minutes), then return to Advanced security options to generate the App Password. For Microsoft 365 work accounts, your IT administrator controls whether IMAP and App Passwords are allowed. If IMAP is blocked at the tenant level, you'll receive an 'Authentication failed' error even with a correct App Password — in that case, switch to the Microsoft Graph approach covered on the `outlook-365-api` page. Store the App Password securely. Do not hard-code it in your Dart custom action as a string literal — you'll pass it in as a parameter from FlutterFlow's secure App State, which is set once during a login or settings screen.

FlutterFlow manages pub.dev dependencies through the Custom Code panel — you don't use a terminal or edit pubspec.yaml directly. In the FlutterFlow editor, click the Custom Code icon in the left navigation sidebar (it looks like angle brackets `</>`). At the top of the Custom Code panel, click the Dependencies button (or the gear/settings icon near the top). A dialog opens showing your current pub.dev packages. Click '+ Add Dependency'. In the search field type `enough_mail`. The package should appear in results — it's a well-maintained IMAP/SMTP/POP3 Dart library. Select it and choose a version — use the latest stable release (check pub.dev/packages/enough_mail for the current version; as of mid-2026 it is in the 2.x range). Click Add. FlutterFlow will validate the package and show it in your dependency list with a green checkmark when resolved. If you see a version conflict warning, try specifying a slightly older pinned version. Also add `enough_mail_html` if you want to render HTML email bodies (optional — not required for plain text). For showing HTML content you'd pair it with the `flutter_html` or `flutter_widget_from_html` package. After the dependency is added, click the Custom Code panel back button to return to the main Custom Code view. You're now ready to write the IMAP and SMTP custom actions that import from `enough_mail`.

In the Custom Code panel click + Add, then select Action. Name it `fetchOutlookInbox`. Set the Return Type to JSON (you'll return a list of message objects). Add two String parameters: `emailAddress` (the user's Outlook address) and `appPassword` (the App Password, passed from secure App State). In the Dart code editor, write the action. The `enough_mail` package provides `ImapClient` for making a TLS connection to Outlook's IMAP server, logging in with plain credentials (which enough_mail sends over the encrypted TLS connection), selecting the INBOX folder, fetching the latest messages, and parsing them into subject/from/date fields. Key IMAP connection details for Outlook: host = `outlook.office365.com`, port = `993`, security = `SslTls`. After connecting, call `login(emailAddress, appPassword)`. Then call `selectInbox()` to open the folder and `fetchMessageSequence(...)` to retrieve the most recent messages. Each fetched message gives you a `MimeMessage` object from which you can extract `decodeSubject()`, `from`, `decodeDate()`, and `decodeTextPlainPart()` for the plain-text body. Note: Custom actions do not run in FlutterFlow's web preview (Run mode in the browser). You must test this on a physical device or install a Test Mode APK. This is a FlutterFlow platform limitation with custom Dart code — not an `enough_mail` issue.

1// FlutterFlow Custom Action: fetchOutlookInbox
2// Parameters: emailAddress (String), appPassword (String)
3// Return type: JSON (List of message objects)
4
5import 'package:enough_mail/enough_mail.dart';
6
7Future<dynamic> fetchOutlookInbox(
8  String emailAddress,
9  String appPassword,
10) async {
11  final client = ImapClient(isLogEnabled: false);
12  try {
13    await client.connectToServer(
14      'outlook.office365.com',
15      993,
16      isSecure: true,
17    );
18    await client.login(emailAddress, appPassword);
19    await client.selectInbox();
20
21    // Fetch last 20 messages (reverse chronological)
22    final mailbox = client.selectedMailbox!;
23    final totalMessages = mailbox.messagesExists;
24    if (totalMessages == 0) {
25      await client.logout();
26      return [];
27    }
28    final start = totalMessages > 20 ? totalMessages - 19 : 1;
29    final sequence = MessageSequence.fromRange(start, totalMessages);
30    final messages = await client.fetchMessageSequence(
31      sequence,
32      fetchPreference: FetchPreference.envelope,
33    );
34
35    final result = messages.map((msg) {
36      return {
37        'uid': msg.uid ?? 0,
38        'subject': msg.decodeSubject() ?? '(no subject)',
39        'from': msg.from?.first.email ?? '',
40        'fromName': msg.from?.first.personalName ?? '',
41        'date': msg.decodeDate()?.toIso8601String() ?? '',
42        'isSeen': msg.isSeen,
43      };
44    }).toList();
45
46    await client.logout();
47    return result.reversed.toList(); // newest first
48  } catch (e) {
49    await client.logout().catchError((_) {});
50    throw Exception('IMAP error: $e');
51  }
52}

Add a second Custom Action named `sendOutlookEmail`. Set the Return Type to Boolean (true = sent, false/exception = failed). Add four String parameters: `emailAddress`, `appPassword`, `toAddress`, `subject`, and `body`. Outlook SMTP connection details: host = `smtp.office365.com`, port = `587`, security = `starttls` (STARTTLS upgrades a plain connection to TLS — different from IMAP's direct TLS on 993). The `enough_mail` `SmtpClient` handles STARTTLS automatically when you set `isSecure: false` and then call `startTls()`, or you can use `SmtpClient.connectToServer` with the appropriate security enum. Build a `MimeMessage` using enough_mail's `MessageBuilder`: set `from`, `to`, `subject`, and the text body. Call `smtpClient.sendMessage(message)` to deliver it. Return `true` on success. In FlutterFlow, add a compose screen with TextFields for recipient address, subject, and body. Wire the Send button's Action Flow: call the `sendOutlookEmail` custom action with the four parameters bound to the text fields and App State credentials. Chain a SnackBar action to show 'Email sent!' on `true` return or 'Send failed' on exception. Remember: this action won't run in web preview — test on device. If you're building a web-first app, the IMAP/SMTP approach is not ideal; consider the Microsoft Graph route on the `outlook-365-api` page instead.

1// FlutterFlow Custom Action: sendOutlookEmail
2// Parameters: emailAddress (String), appPassword (String),
3//             toAddress (String), subject (String), body (String)
4// Return type: Boolean
5
6import 'package:enough_mail/enough_mail.dart';
7
8Future<bool> sendOutlookEmail(
9  String emailAddress,
10  String appPassword,
11  String toAddress,
12  String subject,
13  String body,
14) async {
15  final smtpClient = SmtpClient('outlook.office365.com', isLogEnabled: false);
16  try {
17    await smtpClient.connectToServer(
18      'smtp.office365.com',
19      587,
20      isSecure: false, // STARTTLS — not direct TLS
21    );
22    await smtpClient.ehlo();
23    await smtpClient.startTls();
24    await smtpClient.authenticate(
25      emailAddress,
26      appPassword,
27      AuthMechanism.plain,
28    );
29
30    final builder = MessageBuilder.prepareMultipartAlternativeMessage();
31    builder.from = [MailAddress('', emailAddress)];
32    builder.to = [MailAddress('', toAddress)];
33    builder.subject = subject;
34    builder.addTextPlain(body);
35    final mimeMessage = builder.buildMimeMessage();
36
37    final sendResponse = await smtpClient.sendMessage(mimeMessage);
38    await smtpClient.disconnect();
39    return sendResponse.isOkStatus;
40  } catch (e) {
41    await smtpClient.disconnect().catchError((_) {});
42    throw Exception('SMTP error: $e');
43  }
44}

With both custom actions ready, wire them into your FlutterFlow screens. For the inbox screen, add a Page-Level action (or an On Page Load action) that calls `fetchOutlookInbox` with the emailAddress and appPassword from secure App State. Store the result in an App State variable of type JSON. Use a ListView widget on the page and set its data source to the App State JSON variable. Add a ListTile child that uses JSON path binding to show `$.subject`, `$.fromName`, and `$.date` for each item. To populate App State with the user's credentials securely, create a settings or login screen where the user enters their Outlook address and App Password. Store these in FlutterFlow's Secure App State (FlutterFlow uses flutter_secure_storage under the hood for Secure App State fields). Never store the App Password in a regular (non-secure) App State variable or in a public Firestore collection. For the compose screen, create a Page with three TextField widgets (to address, subject, body). Add a Send Button whose action calls `sendOutlookEmail` with the field values and the credential App State variables. Chain a Conditional action after the custom action: if the return value is `true`, show a SnackBar and navigate back to the inbox; if `false`, show an error SnackBar. To test: click 'Test Mode' in FlutterFlow (top right) to get a QR code or APK. Install it on a physical Android device. Enter your Outlook address and App Password on the settings screen. Navigate to the inbox — emails should populate the list. Try sending a test email to yourself. If you see no data in web preview (clicking Run), this is expected — IMAP/SMTP custom actions are disabled in FlutterFlow web preview. Device testing is required.