Email is still where business arrives. Contact forms send it, customers write it, systems notify through it. And SharePoint, where that information needs to end up, cannot read a mailbox on its own: the old incoming-email feature was limited, on-premises only, and absent from Microsoft 365 entirely.
The Import component of Ultimate Forms closes the gap. It monitors any mailbox, reads each incoming message, and turns it into a structured list item, with the values parsed out of the email body and mapped to the right columns. No code, no farm-level configuration, no manual copying.
This guide walks the complete build: a website contact form whose submissions arrive by email and land in a SharePoint list automatically, including the parsing functions that do the extraction. For every other source the Import component reads, see the complete import guide.
What the email import can do
The capabilities worth knowing before the build.
It works in Microsoft 365 and on premises alike. It connects to any mail server: Exchange, Gmail, or anything IMAP or POP3 compatible. It imports into any list or document library, custom columns included. It can create new items or update existing ones based on conditions, which is what makes email-based updates and syncing possible. And it is configured by site admins, with no backend access or elevated permissions involved.
Filters keep the profile focused: process only messages with a given subject pattern, or only from certain senders, so the ticket mailbox and the newsletter replies never mix.
The worked example: a contact form becomes a list
The scenario mirrors what many organizations run. A public website, hosted outside your network, carries a "Contact Us" form. Each submission emails its details to a shared inbox: first name, last name, company, email address, and a message. The goal: every submission becomes an item in a SharePoint list, with no one touching the inbox.
Step 1: the list
Create a custom list, Contact Requests, with columns for First Name, Last Name, Company Name, and Email (single lines of text), Comments (multiple lines), and Date Received (date and time). Add status columns if you plan to track follow-ups and assignments.
.png)
.png)
Step 2: know your email's shape
A submission email looks like this:
First name: John Last name: Smith Company: ACME Ltd Email: jsmith@acme.com Comments: I really like your product. Please contact me with pricing info.
Structured to the human eye, but to SharePoint it is one block of text. The parsing functions are what turn the block into values.
Step 3: the import profile
In the Ultimate Forms designer, open Import and create a new profile.
Source: type Email, with the mail server details and the shared inbox credentials. Add a subject filter ("Contact Request") or a sender filter so only form submissions are processed.
Destination: the Contact Requests list, creating a new item per message.
Mapping: the part that earns the article, covered next.
Step 4: the parsing functions
Two functions do all the work, and they nest.
$StripHTML solves the format problem. Modern emails are HTML: the text you see is wrapped in invisible tags telling the mail client how to display it. None of that belongs in SharePoint, so $StripHTML([Body]) returns the plain text of the email body, tags gone.
$Extract does the pulling. It scans a block of text and returns just the part matching a pattern you define. Look at the email again: every line is a label, a colon and space, the value, and a line break. That is the pattern. Here is the function for the first name:
$Extract($StripHTML([Body])|?First name: ^\r)
Reading it piece by piece: the first parameter is the text to search, here the output of $StripHTML, because functions nest. The second parameter is the pattern, shaped as prefix ^ suffix. ?First name: is the prefix, with the question mark meaning "anywhere in the text, not only at the start." ^ marks what to extract. \r is the suffix, the line-break character, and it matters: without a suffix, the first space would end the value, and names and company titles contain spaces. With \r, the whole value up to the end of the line is captured.
That function returns "John." The same pattern maps every column:
- $Extract($StripHTML([Body])|?First name: ^\r) for the first name
- $Extract($StripHTML([Body])|?Last name: ^\r) for the last name
- $Extract($StripHTML([Body])|?Company: ^\r) for the company
- $Extract($StripHTML([Body])|?Email: ^\r) for the email address
- $Extract($StripHTML([Body])|?Comments:^$) for the comments, running to the end of the text
Map each function to its SharePoint column, and the profile is complete.

Step 5: test it
Send a test email in the correct format to the monitored mailbox. Wait for the profile to run, then check the list: a new item, every column populated. If a value comes through ragged, refine its pattern and test again. Two or three iterations usually land it exactly.

After the import: the process takes over
The imported record is an ordinary list item, so the rest of the platform picks it up immediately. An alert tells the team a request arrived, with the sender in the subject line. Actions assign the owner, set the category, and send the acknowledgment to the address the import extracted. The dashboard counts it. Nobody re-keys anything, because the data was born structured.
The same build serves far more than contact forms: support tickets, job applications, customer feedback, sales inquiries, and automated system notifications all follow the mailbox-profile-mapping shape. And because the profile can update existing items as well as create them, reply-driven scenarios work too, with the email updating the record it belongs to.
Patterns that survive the real world
A few habits make the parsing robust rather than lucky.
Anchor on labels, not positions. The ?-prefixed pattern finds "Company:" wherever it sits, so a reordered form or an added line does not break the mapping. Patterns tied to meaning outlive patterns tied to layout.
Choose suffixes deliberately. The \r line break captures values with spaces; the end-of-text pattern captures the free-text tail. When a value misbehaves, the suffix is almost always the fix.
Keep the form and the profile in the same conversation. The email's shape is a contract between whoever owns the website form and whoever owns the import. When the form adds a question, the profile adds a pattern, and a one-line note between the two owners beats a week of half-empty columns.
And watch the first week. Real submissions bring surprises test emails never do: odd characters, empty values, unexpected languages. The profile handles them; the patterns just need to meet them once.
When email is the right door, and when it is not
Worth being honest about the architecture. If you control the intake end to end, an external public form writing directly to the list is simpler: no parsing, live validation, no email in the middle.
The email import wins when email is already the channel. The website you cannot change, the partner's system that sends notifications, the customers who will write to an address no matter what, the completed PDF forms that come back by reply. In those cases the inbox is a fact of life, and the import makes it a structured one.
Many solutions run both: the form for the traffic you control, the import for the traffic you receive. Same list behind each, and the process downstream cannot tell the difference.


