Skip navigation

With the new lead scoring module in E10, you'll need to map a different lead scoring field in Eloqua to your CRM field.

It depends on the CRM you integrate with but you'll want to do this for the Update Contact, Update Lead and Create Lead calls.

Go to: Setup > Integration > Outbound (tab) > External Calls (tab) and update each call separately.

 

Choose the Default Scoring Model field and drag it to the Lead Rating field (or whatever you have called it in your CRM). That's it.

8-31-2012 4-40-26 PM.png

This article reviews some of the testing tools that are available for end users of Apps. Not every App that is hosted on cloudconnectors.eloqua.com has every test option outlined below. They are typically found on connectors and feeders (the difference is explained here).

 

NOTE -

This document is not for testing the DEVELOPMENT of Apps. It is meant for end users

 

Accessing the Test Tools

When you are looking at the configurtion window for an app, you will see a series of buttons along hte left hand side. Click on the "Test" button:

test tools.png

 

You will see a potential mix of different tabs, depending on the app you are looking at. The options are as follows:

 

Step Members:

step members.png

This tab shows records that are in the step in Program Builder or Canvas, and what "state" they are in. IF a record appears in a step, but is not represented here, then the Program or Canvas has not executed yet. Clicking the "Refresh counts" button will refresh the number of records in each state.

Awaiting Action - These are records that are waiting for the App to process

In Progress - The app has started processing these records

Complete - The app has finished processing these records (but they are still in the step in PB or Canvas)

 

Under the "Action area, you can select the drop down and change the state of a record to either "Awaiting Action, "In Progress" or  "Complete". You select the option that you would like, and click "Go"

 

Run Manually

Run Manually.png

Run Manually allows you to manually execute the App. It is typically used in both Connectors and Components

You have 2 options:

Dry Run - A dry run executes the call, either on the contacts in a step OR for the relevant contacts in a feeder. There MUST be records in the step within Eloqua. IT DOES NOT modify the data within Eloqua. If there is a per transaction cost with the 3rd party, this will typically NOT use those calls

Full Run - A full run executes the call, either on the contacts in a step OR for the relevant contacts in a feeder. There MUST be records in the step within Eloqua IT DOES modify data within Eloqua. If there is a per transaction cost, it will be incurred.

 

Both run modes display the information back from the third party within the screen. Both only execute off 10 records

 

 

Sample Data

Sample Data.png

Sample Data is typically used with connectors. It allows you to define a contact (which does not need to be within the step in Program Builder or Canvas).

To use, place 1 email address per line. A contact MUST exist in Eloqua with the email address that is inputed.

By default, Sample Data runs as "Dry Run" mode above (where data is displayed, but not committed to Eloqua). If you want to have the data pushed to Eloqua, click on the "Full Run" button.

Click "Test Contacts" in order to execute.

As part of the "Eloqua on Eloqua" series, I'm happy to write about how we use Eloqua to run our New Hire Onboarding.

 

Whenever a new employee joins Eloqua, they experience a timed nurturing campaign that pushes important information to them when they need it. You may be wondering how to build something similar in your organization... well wonder no more, because here's how we did it!

  • We started with defining the process: What happens when a new employee joins? In our case, the hiring manager fills out a form on our intranet and that form submission kicks off a workflow to departments like IT, HR, etc.. We first thought about integrating this form into Eloqua, but then realized the new employee wouldn't have their @eloqua.com email address just yet.
    • Once IT has created the new hire's Eloqua email, our HR department goes to a landing page with a form, hosted internally. That landing page is actually an Eloqua landing page, with the form integrated into an internal Eloqua install that we use for non-Marketing purposes. HR fills in the new hire's name, Eloqua email address, start date and department information.

New Hire - Form.jpg

  • We then designed the HR campaign: What information does every new hire need at each stage of their onboarding? Each piece of information was made into an email, or like information was grouped into one email. We then planned out the timing: Employee Handbook should get sent on Day 1, product videos on Day 10, etc.. Each link in the email went to content on our internal website portal - tracked for click-throughs of course!
    • I'm responsible for the onboarding of new sales people, so I created a parallel nurturing campaign specific to their needs and typical questions.

New Hire - Campaign.jpg

  • The form could be submitted at any time by HR before the new hire starts; but we wanted the first email to get sent the day the new hire arrived at Eloqua. We set up a segment that found folks who were starting within the next day and pulled them into the campaign. That segment also looked at new hires who were in Sales and pulled them into the parallel Sales campaign as well. Which means that a new Sales Rep receives messages from HR as well as messages from me about how to sell Eloqua

New Hire- Onboarding Segment.jpg

  • Once everything was built in the Landing Page editor, Segment editor and Campaign Canvas, we activated the campaign and the rest is history!

Feel free to steal any of the above for your own use. I also encourage you to attend an upcoming Road to Revenue Tour near you, where we'll be presenting this and more "non-marketing" use cases of using Eloqua.

 

... and I'd love to answer any questions about this or hear about any other nifty ways out there that you have developed to onboard your new employees!

This is a non-official post that may or may not work. I've been reviewing some old folders on my laptop and thought this material may be helpful based on some recent posts I've seen. If it doesn't work, post comments and let's work as a community to figure this out. With all that said, here we go!

 

The following post explains how Eloqua users can have content dynamically change on their event landing pages depending on whether or not the event is full. For example, if an event is full, you may want to have a message that lets web visitors know this right away (rather then sending them an email which Eloqua can be configured to do very easily).

 

Before starting this process, ensure that you have the necessary training from EloquaU and have access to the Events Module. This assumes that you have an advanced knowledge of Eloqua forms, landing pages, JavaScript, web data lookups and web design.

 

  1. Create an event using the Events Module - You need at least one session. Be sure to set the max number of registrants for the event.
  2. Create an Eloqua form.
  3. Add the following processing step (for events): Update Event Registration. Select the Event you created in Step 1
  4. Add the form to an Eloqua hosted landing page or to a web page that has Eloqua tracking scripts on it
  5. In order to setup a condition that will allow you to display different content if the event is full, you need to create a data card data lookup. Setup > Website > Web Data Lookup
  6. Create a new Data Look up. Make sure you select “Data Card Sets”. Select "Data Cards" from the Data Lookup Type drop down and the name of your event from the Data Card Set drop down.
  7. Once it's created, in the top right of the screen, go to Data Lookup Options > Get Data Lookup Scripts.
  8. Take the script on the lower half of the page and paste it on the web page or Eloqua hosted page (you'll need to use a Cloud Component in E10 for this). If possible, ensure the scripts are placed under the Eloqua tracking scripts.
    8-30-2012 6-47-05 PM.png
  9. You now need to customize the scripts so the Lookup will be associated with the appropriate Datacard Set (event). Within the <DataCardSet> tags, enter in the ID of the Datacard Set. You can find the ID from the scripts at the top of the page:
    8-30-2012 6-48-51 PM.png
  10. Just add in the ID so it would look like this (you can just remove the “Enter__here” between the “GroupByFieldValue” tags:
    var elqDLLookup = '<DataCardSet>48</DataCardSet><GroupByFieldValue> </GroupByFieldValue>';

    An important item to note is that one Lookup can be used for multiple Datacard sets (events). This is what it would look like: <DataCardSet>11,14,15,16</DataCardSet>

  11. Now you need to add the script that will change the content based on whether the event is full. Below is an example of the script that was added for a sample event (the code doesn't work). It displays alternative text if the event is sold out based on the limit you set in the event. For your event, ensure that you substitute the Datacard Set ID (it’s 48 below) with the correct ID. This was added in from the top section of the page.

<SCRIPT TYPE='text/javascript' LANGUAGE='JavaScript'>

if (GetElqContentPersonalizationValue('IsCourseFull48') == 'False')

{

  document.write('<p><b>Wednesday, July 11, 2017<br> Steve Miller Band</b> (Main Stage)<br> <b>Dog Power </b>(Rogers Stage)</p>'); }

else

{

  document.write('<b><span style="font-size: 11pt;">These tickets are sold out. <br> <a href="http://test.com/index.html"><u>Select an alternate date</u><img src="http://www.test.com/images/arrow-blue.gif" border="0" hspace="5"></a></b></span><br>  <br><br>');

}

</SCRIPT>

 

In a normal situation, the page will display:

Thursday, July 11, 2017

Steve Miller Band (Main Stage)

Dog Power (Rogers Stage)

 

If the event is full, the text will be substituted with:

 

These tickets are sold out.

Select an alternate date

 

EXTRA: Using JavaScript, you can get even further complicated. For example, when the page loads, you can check if the event is full and disable the form fields. Here is another code sample of a multi-city event:

 

 

<SCRIPT TYPE='text/javascript' LANGUAGE='JavaScript'><!--//

 

 

window.onload = initPage;

function initPage(){

 

  if (GetElqContentPersonalizationValue('IsCourseFull11') == 'True')

  {

  document.forms["Event_Registration_TEST"].elements["AppeonPowerBuilder_flag"].disabled = true;

  document.forms["Event_Registration_TEST"].elements["AppeonPowerBuilder_flag"].checked = false;

  }

 

  if (GetElqContentPersonalizationValue('IsCourseFull14') == 'True')

  {

  document.forms["Event_Registration_TEST"].elements["PocketPowerBuilder_flag"].disabled = true;

  document.forms["Event_Registration_TEST"].elements["PocketPowerBuilder_flag"].checked = false;

  }

 

  if (GetElqContentPersonalizationValue('IsCourseFull16') == 'True')

 

  {

  document.forms["Event_Registration_TEST"].elements["ASE_flag"].disabled = true;

  document.forms["Event_Registration_TEST"].elements["ASE_flag"].checked = false;

  }

 

  if (GetElqContentPersonalizationValue('IsCourseFull15') == 'True')

  {

  document.forms["Event_Registration_TEST"].elements["RepConnector_flag"].disabled = true;

  document.forms["Event_Registration_TEST"].elements["RepConnector_flag"].checked = false;

  }

 

}

//--></SCRIPT>

Important: This Cloud Connector/Component will be decommissioned  after March 31st 2017. Please review the App Replacement Cheatsheet for instructions

Tweet Sender

This guide will go over the installation and configuation of the "Tweet Sender" app.

The Tweet Sender app allows you to send a tweet to a contact in Eloqua. IF the twitter handle associated to a contact is follow the authorized Twitter account, a Direct Message (DM) can be sent to the Twitter handle. You can personalize the tweet with up to 2 fields from the contact.

 

It is assumed that users of this guide are comfortable with Program Builder OR Campaign Canvas. This app is supported on ALL versions of Eloqua.

As well, you will need an account on cloudconnectors.eloqua.com to use this connector. Sign up at http://cloudconnectors.eloqua.com

 

 

How to Install the App

As of the writing of this guide, this app is not available on Appcloud.eloqua.com, and must be installed from cloudconnectors.eloqua.com (please see this article to understand the difference).

Visit this URL and click on the "Install Connector" button, and follow the steps (NOTE, your Eloqua user will need to be an adminstrator user in order to install):

https://cloudconnectors.eloqua.com/StepTypeOverview.aspx?StepType=TweetSenderContact

 

Using the Connector

 

The connector is triggered off a contact. It can be triggered from either Program Builder OR Campaign Canvas.

 

Campaign Canvas:

 

The tweet sender is used the same as a regular action in Canvas. Double click or drag "Send to Cloud Connector" from the left hand navigation (under the Actions header). The step will appear. Double click the step, and select "Tweet Sender" from the list:

 

canvas component.png

Click the icon to the right in order to start configuration.

 

Program Builder:

 

The tweet sender executes as a regular action step in program builder.

Create a step in the program where you want the step to execute

Set the action of the step to: “Cloud Connector”

You will be provided with a list of Cloud Connectors that have been created. Select the correct one from the list:

list.png

Click the "Configure" button.

 

Configuring the Tweet Sender

If you are not already logged into Cloudconnectors.eloqua.com, you will be to do so:

cloudconnectors login.png

On the next screen, you will be prompted to input the information for an Eloqua user. Please ensure the user has API access:

cloudconnector login 2.png

 

On the next screen, (configuration) you will need to do 2 things:

- Authorize a twitter account (this is the account that the Tweet will be sent from)

- Define the Twitter Message.

tweet sender config.png

 

Authorize Account:

 

Click on the "Authorize Account" button. This will bring you to a Twitter login screen. Please login with the correct account, and click the "Authorize App" button.

 

Twitter Message:

Here is where you input what the message looks like. URL's will automatically be shortned (using the T.CO shortner), and message longer then 140 characters will be truncated. You have the following configuration options available:

Direct Message - To make this a Direct Message (DM) place a lowercase d at the start of the tweet.

Twitter Handle - to include someone's Twitter handle, include the following ||TwitterID||. If you want to @message them, place it as such @||TwitterID||

Personalization from Contact fields - You can include personalization from up to 2 contact fields. The fields are defined in the "Mappings Area". To include the personalization, please insert: ||Pers1|| and ||Pers2||

 

Mappings:

Under the mappings area, you will map 3 fields from the contact:

Twitter ID - this is the field the Twitter handle

Twitter Personalization Field 1 - This is the field that stores the personalization message ||Pers1||

Twitter Personalization Field 2 - This is the field that stores the personalization message ||Pers2||

 

NOTE - Although you do not need to use both personalizations, you do need to map a field into them

 

Enabling the Step:

Remember, in order for this app to be live, you need to enable both the program/canvas AND the app. To enable the app, click on the "Credentials" tab, and then click the "Enable Step" button:

enable.png

Because Cloudconnectors.eloqua.com sits outside of the standard Eloqua code base, it has a separate release structure, with releases happening in a much more frequent manner.

This post will be updated with release notes for each release. Please check back often, or follow this post for the most up to date information.

IF you have questions, please make a comment and include the release date.

 

October 27, 2012:

  • Improvement - RSS Component added validation for URL structure of feed


October 25, 2012:

  • Overall Speed Enhancements
  • Bug Fix - Static value from query string in Progressive Profiling


October 12, 2012:

  • Form Prepop now supports checkbox fields
  • Bug Fix - email address in pre pop components

 

October 6, 2012:

  • UI Improvements to Box Content app
  • String Manupulator support for large text fields
  • Bug Fix - Form Submit accepting comma

 

September 30, 2012:

  • Fixes to Brainshark feeder
  • Fixes to Survey Gizmo feeder
  • Slideshare embed released

 

September 23 2012:

  • Radian6 "Buzz Widget" available
  • Polls supported in Survey Gizmo
  • Slideshare app available
  • Upgrades to UI framework

September 15 2012:

  • Improvements to Box app UI


September 11 2012:

  • Box embed - General updates
  • Bug Fix - Wrong screen displayed intermittently when editing field mappings
    Lithium - UI Bug fix


September 7th 2012:

  • Continued increase in throughput for connectors
  • Increase in speed-to-pick-up connectors the first time a contact goes into the step
  • Box component had preview added to show live doc
  • Box file explorer added
  • On24 register connector - BUG FIX - not sending blank values
  • On24 feeders now update-but-not-create contacts if setting is set as such
  • Lithium - BUG FIX - dates fixed

 

August 24th 2012:

  • Increase in throughput for connectors for faster execution of large data sets
  • Small UI tweaks
  • Data.com connector - display fields were added (revenue, employees)
  • Progressive Profiling - Ability to upload query strings.

When using progressive profiling as part of your lead nurturing efforts, I've found capturing one high value piece of information at a time works best.  For example, if you are going to offer a case study, video or whitepaper for download, only ask for either email or social media log-in credentials and company name.  Then when a prospect responds to the next call to action in the nurturing series, ask for an additional piece of information such as industry or pain point and deliver content based upon information gathered from previous interactions.  This not only creates a personalized experience but it keeps the tone conversational.

 

In addition, you should be incorporating your lead scoring criteria into this process so subsequent interactions will boost up your prospects lead score! With any relationship, it's best built over time and there's no better way to do this then with progressive profiling.

 

As a next step, why not try out progressive profiling using Eloqua's new Cloud Component How to do Progressive Profiling in E10 Using the Cloud Component

Has anyone come up with a good way to create a form or something that allows people to register for Pod space at a meeting and once that space is filled, the option is automatically removed?

 

For example, if at Eloqua Experience, I have 5 pods to assign in 30 min. increments, the pods are assigned for 5.30 - 6.00 pm but only 3 are being used from 6.00 - 6.30 pm.  The registration for the 5.30 - 6.00 pods will close but the 6.00 - 6.30 is still open.  Ideally, this would be automatic...

This seems counter-intuitive. What's the reasoning around this not happening?

 

It would really speed up the campaign building process, especially for monthly campaigns.

 

Thoughts?

Create a data card and create a Contact and map the data from the data card onto the newly created Contact.

 

In E9, navigate to:

Evaluate > Database Management > Custom Objects > Data Card Set > Data Card Services > New Data

(if the data card services are being launched for the first time which would then enable the transfer of data from all existing data card to contact.)

1. Add Processing steps, "Save to Contact Table" and "Update existing record or Data Object"

2. For the processing step, "Update existing record or Data Object", you can then choose an existing Update Rule or create a new one--you will likely need to create a new one for the project at hand; however, if you create a new Update Rule from Data Card Services it will never give you the option to choose a database table (Contacts, Prospects, Companies, Custom Object). It will always default to the exact Data Card Set you are working in. Clearly, this will NOT work for transferring data card data to the contact table because you cannot map/align the two objects. To get around this you must visit step 3.

3. Navigate to Evaluate > Data Tools and click, "Create New Update Rule Set"

4. Create a new Update Rule and Select Contacts as the Table to update. Add the Contact Table fields you would like to update. Save.

5. Go back to your Custom Object/Data Card Set's Data card Services and open the "Update Existing Record or Data Object" process step you created and select the Update Rule you just created.

6. Map the Data Card field to Contact Field and Save and Close.

 

Repeat this process for modified data in Data Card Services, but do not place the "Save to Contact Table" step.

 

Run some tests and you will see net new contacts get created and modified ones map data card data onto their contact record.data_card_sets

I recently set up a campaign that uses the Form Submit Cloud Connector and ran into an unexpected problem. I thought I'd share my experience with everyone so you don't duplicate my error.

 

My campaign sent leads to the Form Submit Cloud Connector in order to trigger multiple actions off a "blind" form submission. When I turned on the campaign and leads started flowing through, I noticed that the same group of leads kept "submitting" the form over and over again. After several discussions with Eloqua Support, we finally figured out that my form had required fields on it, and the leads who were looping through the program were missing one of the required fields. I changed the form so none of the fields are required and now it's working as expected.

 

When setting up a Form Submit Cloud Connector make sure:

1. All of the leads running through the Connector have the required fields.

or

2. Do not make any of the form fields required.

Shared Items on Eloqua:

  1. Shared Content
  2. Shared Lists
  3. Shared Filters

   4.  Dynamic Content (can be shared)

 

  1.    Shared Content

Shared content is reusable content snippets that you can create once, then reuse in different emails and landing pages.  It allows you to ‘build once, re-use everywhere’ for your most common pieces of content. 

 

Example: Biography on a company person that speaks often at events or on webinars.

Example: “About” company information; ABC company is a global leader of …..

Example: Common product ‘blurbs’. 

 

Check this post for more info:

http://topliners.eloqua.com/groups/eloqua-product-documentation/blog/2012/05/03/shared-content-overview


2.    Shared Lists

Shared lists are a group of contacts with something in common (like a tradeshow list) and sharing the list allows others in your company using Eloqua the ability to add to this list or email to this list.

 

Example:  NA-TRADE-ABCshow-Nov2012 is a Shared Lists.  I uploaded the contacts I got from the recent tradeshow into a shared list so the marketing communication manager can send the follow up email to this list of contacts.

 

Check this post for more Info:

http://topliners.eloqua.com/message/2503#2503

 

3.       Shared Filters

Filters that are created using profile (like industry) and/or engagement (activity filter like everyone that opened this email in the last 60 days) that are shared so the whole marketing team and use them. 

 

Check this post for more info:

http://topliners.eloqua.com/groups/eloqua-product-documentation/blog/2012/05/02/shared-filters

 

4.       Dynamic Content (which can be shared!)

Dynamic content allows different email or landing page content to be substituted depending on rules and associated criteria. 

 

Example: Show a different list of training sessions based on region or city.

Check this document for more info:

  https://eloqua.box.com/s/de44dd63fe1badca1ccb

When salespeople chat with potential clients on the shopfloor or sales meetings they usually make notes either mentally or to a notepad. The information often stays silent between the ears of the salesperson or stay hidden inside the covers of the notepad. As most salespeople hate feeding stuff into CRM there should be a more friendly way to enrich data.

 

A solutions to this might be to create a custom form that a salesperson could fill out during the conversation using a pad or a smartphone. The form could be formulated to use predetermined picklists to enter the solutions, products and services the potential customer has or needs. The form could also include a budget, timeframe and other company data. Upon completion the form data would be saved to a custom object and fed to CRM. Some of the data could be updated into contact fields and then used to create a BANT score. The BANT score could then be included in the lead scoring. The data would also trigger campaigns depending on what the salesperson entered into the form. The client could be sent document packages or even quotes straight away.

 

Any thoughts on this? Has anyone ever implemented something like this? How could we gate the form page so that only authorized people could be able to enter the form page? What else could the system be used for? Any problems this kind of system might create?

Problem Statement:

Often time’s lists from clients (or internal "exclude" lists contain company names, domains, or email addresses need to be suppressed from a particular segment. This is a method of performing the match evaluation, without importing the data into the main Eloqua tables.

 

Solution Summary:

A picklist is created containing the company names (domains,or emails) to be excluded from the segment. From the segment builder, the “In List” or “Not in List” can be used to match the records.

 

Pre-Steps

Cleanse the data to be imported by narrowing it down to a two column spreadsheet. I use excel for this. One column should be the criteria you intend to suppress, and the other (I name ID) can just be a numbered list (See Below).  This step will make importing much easier. Later, the “Company” column will be mapped to the “Option Value” and the “ID” will be mapped to the “Option Name”.

cleaned list.jpg

 

Process Steps:

From the setup Menu, Select "Manage Picklists":

 

step_one.jpg

Manage Picklists Button.jpg

 

In the upper right, select "Select Lists", then "New Select List"

 

New Select List.jpg

Give the list a Name - This will be the name you look for when building the Filter in the Segmentation Tool.

 

Name the select list.jpg

 

Select Save.

 

from the upper right "Select List" button, choose the "Upload Select List" Option. This will bring up the list upload wizard.

 

Upload the Select List.jpg

Once the wizard opens, you can name the upload, and describe it. These are not needed, and will fill in automatically. The important part is selecting your file type to upload.

 

Select List Upload.jpg

Once the file type is selected, go to "Next" this will prompt the user for the data source:

 

 

 

Select file to upload.jpg

 

Browse to your file, and then "Upload and Preview Data"

 


preview data.jpg

 

Select "Next" This screen is just a preview of your data. The next step (very important) is mapping the data:

 

This screen is where you map the fields to the table in Eloqua. I map the "Company" field to "Option Value" and the "ID" field to "Option Name"

 

Option Value Revised.jpg

 

Select "Next" through the next steps (they are just 'admin / reporting' steps)... This is the window you will arrive at. If you have "Success" close the dialog window, and you can go directly into the segmentation tool.

 

success.jpg

 

Now - A list (or table) exists which you can compare values to from the segmentation tool.

 

Open the segmentation tool, place a "Filter Criteria" on the board, Select the field you want to match, and then drop down to the "In List" (or "Not in List") options:

 

final pic.jpg

 

Now the "Match Evaluation" is performed, and you will filter the contacts by whatever field matches your list. If you are trying to "Exclude" contacts from those companies, you can change the filter to "Switch to Exclude" or you could use the "Not in List" option when building the expression.

 

The maximum number of visible rows in these select lists is 2500. However, I've tested this method with over 4500 rows - the Match will still work

 

If anyone tries this, I'd love to hear feedback on this post.

 

Cheers

As we are creating a function for an online support form that would write a time stamp in local time in order to better track service response times, I started to wonder how Eloqua could help service staff to follow up on service requests and create a better experience for the client.

 

When something stops working people tend to be sensitive about the smallest details. They want to know if their request has been received and when the problem will be solved. They need to feel that their needs have been attended to and they are taken seriously. Even the smallest things, like a call from a service person two minutes after the request was made could make a huge difference and boost satisfaction and overall experience. By exceeding customer expectations the satisfaction levels could even go beyond what could be achieved if everything worked in the first place and there was no need for any service.

 

How could Eloqua reduce service response times and help to create a better service experience for example in the ICT sector.  A few ides came to mind:

  • After the customer fills out a service form the request would automatically be directed to an appropriate service person according to contact and form info and form fields. No middle men or administrative steps.
  • The service person would get an email or a text message and he could respond directly to the person who sent the form, offer support or make an appointment.
  • During the service visit, the service staff might use a mobile device to fill in a dedicated Eloqua form. The form would include customer need probing and the service person could register the visit to the system and report the problems fixed.
  • After the visit the customer would get an automated satisfaction survey regarding the visit.
  • By using custom objects and cloud components the service manager could track response times and customer satisfaction. Sales staff could get information on sales opportunities.

 

Has anyone ever implemented anything like this? How could this be done and do you have any ideas how to use Eloqua to make the service experience better for both the client and the service staff?

Just got the new lead scoring program enabled. Wow. Great work.

 

This is exactly the kind of marketing-specific, purpose-driven functionality that allows me to do my job better and more efficiently. Kudos.

 

I'd love to see other applications like this developed for any standard areas where we marketers all do pretty much the same thing, for example:

  • Webcasts and other events - this might just be a template on steroids, but these type of events are fairly standard fare as far as setup and coms is usually concerned.
  • PPC and search marketing - so much work could be done here to help easily connect the inbound data coming from query strings...
  • Data normalization - think update rules on steroids with an easy to use interface
  • ????

 

It's time to start taking the word "automation" seriously... ;-)

The new lead scoring model is launching soon. Are you planning to migrate your existing model to the new one? Are there any benefits from transferring or is it just too much work? It seems to me, that the new model allows easier tuning on the go. One more advatage might be with future improvents in RPM tools that propably will be aligned with the new system.ing

The Scenario

 

Let's say you want to execute an email campaign for a select list of contacts, rewarding them with a free t-shirt for being a valued customer. In order for the contact to receive the t-shirt they must fill out a form by clicking a link in your email. But then somebody outside of your select list gets wind of the promotion and posts a link to your form on a “deals” website. This action drives unwanted traffic to the form and obligates you to distribute more free t-shirts than your budget allowed! Not a pretty scenario is it?

 

Prevention

 

So how do you set up your form to prevent these unwanted visitors from crashing your party? Well, it's a process, but it can be done with the combination of Eloqua Visitor Web Data Lookups, Eloqua Web Contact Group Lookups and the use of query strings in your email links. Yep, that is all it takes, along with a little JavaScript savvy, to create a super secure form that only the contacts you specify are allowed to view the form.

 

Eloqua Setup

 

First thing's first. To start the process you will of course need to setup your email in Eloqua and append a query string to each link you have directing your contact to the free t-shirt form. Let's say it looks something like:

 

http://promotions.mycompany.com/forms/reward?promo=tshirts


In addition, Eloqua will append a unique code to the end of this query string to identify your contact. So the final link in your email will look something like this:

 

http://promotions.mycompany.com/forms/reward?promo=tshirts&elq=0605fa364913417ba80b3611ab5423t1

 

Verification

 

As part of the process we will check and verify that the 'promo' variable is contained within the query string when the form is loaded.  If it is, then we will allow the visitor to view the form, but if this value is not present, we will redirect them to your home page and prevent them from viewing your form.

 

Second, you will need to create a new Contact List (Contact Group in E9) and add to it all of the contacts you have targeted for the email promotion.  We will use this Contact List to verify if the visitor is in our campaign or send them along their way if they are not. While you are setting this up, go ahead and setup a second Contact List to place those contacts that sign up for the t-shirt as we will use that List to prevent multiple form submissions from the same contact.  Nifty, isn't it?

 

Next, you will need to setup both a Visitor Web Data Lookup with a contact view to return your visitor's email address and a Contact Group Web Data Lookup that will return the unique code for your Contact Lists.  The unique code for your Contact Lists will be displayed on your Contact List details page once you create it.

 

Finally, to complete the Eloqua setup you just need to add a Processing Step to your Eloqua form that places each contact that submits the form into the second Contact List you created.  That's it!  Well, at least on the Eloqua side of things...

 

Coding Your Form

 

Here I will assume you have setup a standard form before, so we won't get into the HTML/CSS specifics.  Suffice it to say we have a short form that looks something like this:

 

<form action="http://sXXX.t.eloqua.com/e/f2" name="reward" method="post"> 
    <!-- Hidden fields -->
    <input type="hidden" name="elqFormName" value="reward">
    <input type="hidden" name="elqSiteID" value="XXX">
    <input type="hidden" name="C_EmailAddress" id="C_EmailAddress" value="<eloqua type='emailfield' syntax='EmailAddress' />">
  
    <fieldset>
        <label for="size">T-Shirt Size:</label>
        <select name="size">
            <option selected="selected">Please Select Your Size</option>
            <option value="1">Small</option>
            <option value="2">Medium</option>
            <option value="3">Large</option>
            <option value="4">X-Large</option>
        </select>
    </fieldset>
    <fieldset>
        <label for="color">T-Shirt Color:</label>
        <select name="color">
            <option selected="selected">Please Select Your Color</option>
            <option value="1">Red</option>
            <option value="2">Green</option>
            <option value="3">Blue</option>
            <option value="4">Black</option>
        </select>
    </fieldset>
    <fieldset>
        <label for="Pros">Tell Us Why You Love Us:</label>
        <textarea name="Pros" cols="60" rows="5"></textarea>
    </fieldset>
    <input type="submit" value="Submit">
</form>

 

Don't forget to set your Eloqua Site ID (XXX) in the form action attribute and in the “elqSiteID” hidden field value.  Also, when customizing your form replace the form name “reward” to your form HTML name in the form tag name attribute as well as the "elqFormName" hidden field value.

 

I thought I'd mention...

 

One more thing to mention in this form setup is that we made the email field a hidden field.  Why you ask? Well, because we already have a relationship with these contacts and know their email address, we won't waste their time by asking them to enter yet another time.  A good user experience rules! We will use Eloqua functionality to fill out the email field when they click through to the form. 

 

It is easy and painless and we will use the email value from the field when it is submitted to put them into the second Contact List we made before so we can ensure they only get one t-shirt.

 

Detecting the Query String

 

Now that that is out of the way, let's move on to the fun part! We will start with the JavaScript to verify that the query string is present and that it contains the variable “promo” and that it is set to “tshirts.” This code will need to be placed between your  <head></head>  tags so it is evaluated immediately upon arrival to the form.

 

<!-- Query String Confirmation Script -->
<script type="text/javascript">
    var queryParams = {};
        (function () {
            var match,
                pl     = /\+/g,  // Regex for replacing addition symbol with a space
                search = /([^&=]+)=?([^&]*)/g,
                decode = function (s) { return decodeURIComponent(s.replace(pl, " ")); },
                query  = window.location.search.substring(1);

            while (match = search.exec(query))
               queryParams[decode(match[1])] = decode(match[2]);
        })();
    if (!queryParams["promo"] == "tshirts") {
        window.location = 'http://www.mycompany.com'; 
    }
</script>  

 

This code was borrowed from Andy E. posted at Stack Overflow.

 

Without getting too technical, this code will check for and read the query string then verify if the variable “promo” exists.  If it does, the rest of the page will continue to load, however, if it does not exist it will forward the visitor to the My Company home page.

 

To customize the script for your promotion, simply change the “promo”  and the "tshirts" values on the line where it says


if (!queryParams["promo"] == "tshirts") {

 


to match your query string variable and value, and change the


 

 http://www.mycompany.com

 


to the url where you will be redirecting your visitor.

 

This step will eliminate most of the link reposts that can occur around the web and will generally stop outsiders that do not receive an email with query strings in the link.  But, it is not fool-proof in and of itself, so there is more work to do.

 

Verifying the Visitor is an Intended Contact

 

The first script we will cover is your Eloqua Web Data Lookup settings.  This is where you will customize your form to work with your Web Data Lookup IDs and the Contact List Unique IDs that will be used in the scripts that follow.  The Data Lookup Scripts that follow will also be placed in the  <head></head> section of your form, simply copy and paste and then change the values in the first section to those for your Eloqua instance and other Eloqua elements.

 

The following code was borrowed from Eloqua's Chris Mapili and modified for Contact Group Data Lookups.

 

<!-- Eloqua Data Lookup Scripts -->

<!-- SCRIPT SECTION 1:  Variables that need customizing based on your Instance of Eloqua-->
<script type="text/javascript">
    // START --> MAKE YOUR CHANGES HERE

    // The Site ID of your Eloqua Instance
    var EloquaSiteID = "XXX";
    // Path to elqCfg.min.js
    var EloquaScript = "http://img.en25.com/i/elqCfg.min.js"; 
    // LOOKUP A: The ID of your Visitor Web Data Lookup
    var LookupIdVisitor = "181b80bf-b527-4c85-9d6b-4ca363afb999";
    // LOOKUP B: The ID of your Contact Group Data Lookup
    var LookupIdPrimary = "49d62966-9e8b-4104-84d7-227be99f9999";
    // Unique field's HTML Name from LOOKUP A (usually V_Email_Address)
    var VisitorUniqueField = "V_Email_Address";
    // Unique field's HTML Name from LOOKUP B (usually C_EmailAddress)
    var PrimaryUniqueField = "C_EmailAddress";
    // The ID of your Eloqua Form
    var EloquaFormID = "reward";
    //CONTACT LIST A:  The unique ID of the Contact List for Intended Contacts
    var intendedContactsListID = "181b80bf-b527-4c85-9d6b-4ca363afb999";
    // CONTACT LIST B:  The unique ID of of the Contact List for each form submit
    var promoParticipantsID = "181b80bf-b527-4c85-9d6b-4ca363afb999";

    // END --> MAKE YOUR CHANGES HERE
</script>

 

The second Web Data Lookup script involves dynamically building scripts from Eloqua that are populated with your  Web Data Lookup values for your visitors.  You will not need to make any changes to this section, simply cut and paste it immediately after the first section above.

 

<!-- SCRIPT SECTION 2:  Standard Eloqua Asyncronous Tracking Code | The unique values have been placed in Variables (EloquaSiteID and EloquaScript) -->
<script type="text/javascript">
    var _elqQ = _elqQ || [];
    _elqQ.push(['elqSetSiteId', EloquaSiteID]);
    _elqQ.push(['elqTrackPageView']);

    (function () {
        function async_load() {
            var s = document.createElement('script'); s.type = 'text/javascript'; s.async = true;
            s.src = EloquaScript;
            var x = document.getElementsByTagName('script')[0];
            x.parentNode.insertBefore(s, x);
        }
        if (window.addEventListener) window.addEventListener('DOMContentLoaded', async_load, false);
        else if (window.attachEvent) window.attachEvent('onload', async_load);
    })();
</script>

 

The third Web Data Lookup script will determine if your visitor is in the Intended Contact list or has already submitted the form. If they are not part of the Intended Contact list, they will see a message that the offer is only valid for selected contacts and that they will be redirected to the My Company home page. Furthermore, if they have already submitted the form, they will get a message that says they have already specified their t-shit size and color and that they will be redirected to your home page. 

 

Just copy and paste this script in your <head></head> section directly following section two above. All you will need to customize in this section are the messages you want to display for both not being in the Intended Contact List and already having placed their t-shirt order, and the URL of the page(s) where you want to redirect the visitor.

 

<!-- SCRIPT SECTION 3:  Eloqua Contact Group Data Lookups -->
<script type="text/javascript">
    function groupLookup() {
        var intendedContact = GetElqGroupMembershipStatus(intendedContactsListID);
         var inGroup = GetElqGroupMembershipStatus(promoParticipantsID);
        if (intendedContact != true) {
            alert("This offer is only valid for selected contacts.\nYou will now be redirected to the My Company home page.");
            window.location = 'http://www.mycompany.com'; 
        }
        if (inGroup == true) {
            alert("You have already specified the size and color of your t-shirt. Thanks!\nYou will be redirected to the My Company home page.");
            window.location = 'http://www.mycompany.com'; 
        }
    }
</script>

 

Finally, in the fourth section the script will read the Eloqua Web Data Lookup values returned by Eloqua.  First it will find the visitor's Eloqua cookie and find the visitor by email address.  Then, having identified the visitor, it will look for the Contact Group data and fire up the script in section three to verify the visitor is on the intended contact list.  You will not need to customize this code, simply copy and paste it into your <head></head> section immediately after section three.

 

<!-- SCRIPT SECTION 4:  Eloqua Web Data Lookups -->
<script type="text/javascript">

    // SetElqContent is triggered by the Data Lookup Scripts automatically.  The "FirstLookup" modification allows for the Visitor Lookup to trigger the second Lookup (Contact/Datacard/Prospect/Company)
    var FirstLookup = true;
    function SetElqContent() {
        if (FirstLookup) {
            //LOOKUP B:  Eloqua Contact/DataCard/Prospect/Company Data Lookup from Email Address
            _elqQ.push(['elqDataLookup', escape(LookupIdPrimary), '<' + PrimaryUniqueField +'>' + GetElqContentPersonalizationValue(VisitorUniqueField) + '</' + PrimaryUniqueField + '>']);
            FirstLookup = false;
        } else {
            //This is triggered the after Lookup B fires.  LoadFields starts the field prepoulation process.
            groupLookup();
        }
    }

        // LOOKUP A:  Eloqua Visitor Data Lookup from Cookie  -  Ensure VisitorUniqueField is pulled in the Profile View
        _elqQ.push(['elqDataLookup', escape(LookupIdVisitor), '']);   
</script>
<!-- End Eloqua Data Lookup Scripts -->

 

There you have it!

 

Now you have a gated form that will only allow those contacts you intend to view the form actually see the form. But wait! What if your intended contact is on a brand new machine and does not have an Eloqua cookie needed to identify them based on your Contact Group Web Data Lookup?

 

Well, as it turns out, the preceding Eloqua script will know there is no cookie and lay one down based on the Eloqua unique ID provided in the query string in your email links.  But, the form will load before that cookie is laid down and your Web Data Lookups will not fire.  This could be a potential loophole, albeit not highly probable. 

 

Keep your chin up, there is a way to deal with this and verify that the contact is an Intended Contact! We just need to add one more script to the bottom of the form that will refresh the page after a second enabling it to read the newly laid cookie and proceed with your verification process. Simply paste this code just before the  </body>  tag at the end of your page.

 

<script type="text/javascript" >
    setTimeout(function() {
        if (!window.GetElqGroupMembershipStatus){
            document.location.reload(true);
           }
    },1000);
</script>

 

Now you can sleep soundly tonight, knowing your offer won't be blown up by unintended visitors filling out your form for the free t-shirt.  And as a bonus, here is a complete script you can copy and paste then test it out with your Eloqua instance information and unique IDs.  Good luck!

 

Putting it all together

 

To see this project put together in a complete HTML file, visit my blog.

In a recent project we had to build a vast amount of webinar registration, whitepaper download and contact us forms in 19 different languages. The total amount of forms was 418, meaning that the expected outcome or action of each form was unique. For example a gated download form had to deliver a link to a number of individual PDF documents (one per form) or perform different actions like webinar registrations depending where the form was called from. Obviously the forms had to be pre-populated. If a prospect fills a form to download document A, we should not ask him/her to key in all the data again when document B is requested etc.

 

Since building 418 forms is a formidable task even by using the new, fantastic form management tool in Eloqua 10, we thought there must be a better way.

On the form field level there were only two different types of forms:

  • a small gated download form with just basic contact information fields
  • a more complex contact us and webinar registration form with additional fields

 

We ended up building 38 unique forms, one of each form type for each language (19+19). We thought we could have even reduced this to only 2 by parameterizing the languages, but we felt that this would lead to an overly complex form. Handling the languages separately made for example the form validation part easier, since we could use Eloqua’s own validation system.

 

Each form sat on its own minimal, language dependent Eloqua landing page and had one adjacent thank you landing page. The forms were called on client’s corporate website using a JavaScript window.open method to remove unnecessary browser bars and to center the form on top of the page it was called from. We had preferred opening the forms as beautiful shadowbox overlays, but in this case it was not possible due to limitations of the corporate web CMS used.

 

Without going too much into details, this is what we did and how we will instruct our employees to do in the future:

 

Tip #1: 

Plan well ahead and map the differences and similarities between all your forms. Build one form of each type first as readyas possible and test it properly. Set up validation and all processing
steps needed. Once everything works and is approved by the client, then save the form as a template and use it to create language versions by modifying field labels and validation error messages.

 

Tip #2:

Use query string parameters and JavaScript to extend the form functionality. This enables you to have just one form for multiple purposes.
Let’s say the URL ofthe gated download form on Eloqua is http://marketing.yoursite.com/ENdownload.
When called in context of downloading document A, the URL becomes http://marketing.yoursite.com/ENdownload?doc=documentA.

Use JavaScript to grab this parameter value on the form page and add it to the end of a hidden field “thankYouPageURL” value (already containing a default value “http://marketing.yoursite.com/ENThankYou?doc=”) to carry it over to the next page. This will tell the thank you page what to do.
Create a processing step “Redirect to Web Page” determined by this form field.
On thank you page, grab the value again and serve the appropriate document using JavaScript. 

 

Tip #3:
Always store your custom JavaScripts into files located on an external web server, not inline on Eloqua landing pages or in the Eloqua Component Library File Storage. Just make a reference to your scripts on the Eloqua landing pages. There are multiple benefits:

  • Making system-wide changes to your scripts is much easier when the files are stored in single location.
  • Script editing is more convenient using a professional code editor with code highlighting and FTP capabilities (UltraEdit is my favorite).
  • Soon you will have a modular, thoroughly tested generic Eloqua JavaScript library (think Swiss army knife) of your most timesaving functions. Starting a new project with a new client will be faster.

 

Tip #4:

Using a JavaScript Framework like jQuery or Prototype improves cross-browser compatibility and shortens development and testing times.

 

Tip #5:

Use hidden fields to record the action type performed. In this case we used “Lead Source Original” and “Lead Source Most Recent”. LSO is written to corresponding contact field only if the field is previously empty. LSMR is always updated. In this case we grabbed the form action parameters (see Tip #2) with JavaScript and populated the hidden fields accordingly. This allowed us to identify where the conversion originated, i.e. what initially made the prospect to give his/her contact details. In general you should always include LSO and LSMR on all forms. There are multiple uses, normally lead sources relate to inbound marketing channels (Adwords, banners, email etc.), but you can use them as you like.

 

Tip #6:

Use custom data objects to store all form data. There are multiple benefits:

  • You don’t need to consume contact or account table fields for data that really doesn’t belong there
  • Custom data objects can be used for profiling
  • All form activity data is stored in one location and can be exported easily (without going into each form individually and taking the “View Submission Data” option.

Note: If you want to capture multiple actions per user instead of updating a single data row, leave “Select the Key Field” undefined.
If you set the email address as the key, only one record per user will be created.

 

Tip #7:

Do not embed the Eloqua forms inside iFrames on client’s corporate website. Even if it works most of the time, you should not because:

  • Layout issues: If you later need to modify the form page size (add text, add fields), you would have to also change the iFrame size on corporate web CSM  (at every form instance in the worst case).
  • Tracking and pre-population: In most cases both do work, but depending of the user’s browser security settings, the Eloqua cookie may be rejected (as a 3rd party cookie) leading to mismatch in tracking and preventing pre-population.

If you really have to have the form on the actual website, build it there and just integrate it to Eloqua.

 

Tip #8:

Always add a processing step “Add to Program” to every form, even if you don’t need it for now. Create a one step program in program builder doing nothing and activate it. This enables you to later extend the functionality of all your forms without tweaking each and every form individually. Program builder is very powerful and with it you can implement complex conditional processing that can’t be done using the form processing steps.

 

Tip #9:
Pre-populate forms for recurring visitors (who visit the site without having the elq parameter in the URL). If I fill a form today to download a whitepaper and return tomorrow to download something else, why would I have to key in my data again? We first tried to implement this using the new Form Population (beta) Cloud Component, which at the time (June 2012) did not work for us. We ended up using Web Data Lookups instead, which worked wonders. Ok, it required a bit JavaScript coding, but was worth it. It’s in our JavaScript library now.

 

Tip #10:

You can easily integrate the webinar registration functionality to your Eloqua forms using “Post Data to Server” processing step to submit data into Eloqua and to an external webinar system in one pass. To manage this, we studied the webinar system’s (GoToWebinar in this case) registration form HTML and duplicated the fields with proper default values as hidden fields on our Eloqua forms.
The benefits are:

  • One form submits data to two systems, Eloqua and GoToWebinar.
  • You don’t have to add “Send Submitter an Email” processing step to your Eloqua form, since GoToWebinar will send it for you and does it much better (including all webinar details, phone numbers, cancellation and add to calendar links etc.)

 

This article explains the form setup side of the campaign my colleague Tero Rantaruikka explained in his fine article:
http://topliners.eloqua.com/community/see_it/blog/2012/07/31/keeping-all-the-stings-attached

The Eloqua AppCloud lets Eloqua clients integrate with webinar events providers quickly and easily.

Currently, Eloqua has prebuilt integrations with the following webiner providers:

  • Adobe Connect
  • Citrix GoToMeeting
  • On24
  • Readytalk
  • WebEx

 

Each provider is slightly different. So, this article will walk through the different connection points that are available, as well as the different fields returned per call.

 

First off, some definitions:

  • Register- This is the act of registering an Eloqua contact through Campaign Canvas to an event
  • Unregister - This is unregistering an Eloqua contact through Campaign Canvas to an event
  • Query - This is taking an Eloqua contact, who has hit a specific step in Campaign Canvas and seeing if they are registered for an event
  • All Viewers - This is a sych that runs on a regular interval (daily, weekly, monthly) OR just one time, and returns everybody who viewed an event. The data can be stored on a contact OR a custom object (data card)
  • All Registrants - This is a sych that runs on a regular interval (daily, weekly, monthly) OR just one time, and returns everybody who registered for an event. The data can be stored on a contact OR a custom object (data card)
  • Join Meeting URL - Some providers have a unique join meeting URL, which is returend when a contact is registered. This URL can be stored on a contact, and prepopulated in an email
  • Send Registration Confirmation - Some providers will trigger a confirmation email to a contact when that contact is registered. This is an email not sent by Eloqua
  • Multiple Events - This is the ability to store an "event ID" on a contact, which can be used by the step to determine which event to register a contact for. It allows for 1 step to be used for multiple events

 

Calls Offered:

RegisterUnregisterQueryAll Viewers (Feeder)All registrants (Feeder)Join Meeting (URL)Send Registration confirmationMultiple Events
Adobe ConnectYYYYY
Citrix GoToMeetingYYY
On24YYYY
ReadytalkYYYYconfigurable
WebExYYYYConfigurableY

 

 

Fields Returned:

 

Adobe ConnectCitrix GoToWebinarOn24ReadytalkWebEx
CallRegisterQuery AttendanceAll Viewers QueryRegisterQuery AttendanceAll Viewers QueryRegisterQuery AttendanceAll Viewers QueryAll Registrants QueryRegisterQuery AttendanceAll Viewers QueryRegisterQuery AttendanceAll Viewers
EntityContactContact/Data CardContact/Data CardContactContact/Data CardContact/Data CardContactContact/Data CardContact/Data CardContact/Data CardContact/Data CardContact/Data CardContact/Data CardContact/Data CardContact/Data CardContact/Data Card
ICS File w/ Join LinkReceived
Meeting Details (Title, Audio info etc...)Received
URLReceivedReceivedN/AReceivedReceived
First NameSentSentSentReceivedReceivedSentReceivedSent
Last NameSentSentSentReceivedReceivedSentReceivedSent
Email AddressSentSentSentReceivedReceivedSentSentReceivedSent
CompanySentReceivedReceived

Sent

ReceivedSent
Job TitleSentReceivedReceivedSentReceivedSent
Address 1SentReceivedReceivedSentReceivedSent
Address 2SentReceivedReceivedSentReceivedSent
CitySentReceivedReceivedSentReceivedSent
StateSentReceivedReceivedSentReceivedSent
ZipSentReceivedReceivedSentReceivedSent
CountrySentReceivedReceivedSentReceivedSent
Home PhoneSentSentReceived
Work PhoneSentReceivedReceivedSentReceivedSent
Company IndustrySentReceivedReceivedSentReceived
Job FunctionSentReceivedReceivedSentReceived
Company SizeSentReceivedReceivedSentReceived
Custom Fields10 - Sent51033
Minutes AttendedReceivedReceivedReceivedReceivedReceivedReceivedReceivedReceived
Number of Questions AnsweredReceivedReceived
Live Attendance DurationReceivedReceived
Archived Attendance DurationReceivedReceived
Polls AnsweredReceivedReceived1010
Surveys AnsweredReceivedReceived
Questions AskedReceivedReceived
Start TimeReceivedReceivedReceivedReceivedReceived
First Entrance TimeReceived
Last Exit TimeReceived
DepartmentReceivedReceivedSentReceived
Partner Ref fieldReceived
Late Registrant Handling for E9Available
Automatic Check for New ContactsAvailable
Meeting IDReceivedReceivedReceived

 

 

*NOTE - Sorry for the poor formatting of the table, I am limited in how I can format it. I will attach an XLS with the info as well

**EDIT - This article has been updated to reflect changes in the ReadyTalk app, which can be downloaded from here:ReadyTalk Connectors | Eloqua AppCloud | All the apps for Eloqua in the cloud!**

Filter Blog

By date: By tag: