MementoEmbed and Raintale for Web Archive Storytelling

08/01/2020 ∙ by Shawn M. Jones, et al. ∙ 0

For traditional library collections, archivists can select a representative sample from a collection and display it in a featured physical or digital library space. Web archive collections may consist of thousands of archived pages, or mementos. How should an archivist display this sample to drive visitors to their collection? Search engines and social media platforms often represent web pages as cards consisting of text snippets, titles, and images. Web storytelling is a popular method for grouping these cards in order to summarize a topic. Unfortunately, social media platforms are not archive-aware and fail to consistently create a good experience for mementos. They also allow no UI alterations for their cards. Thus, we created MementoEmbed to generate cards for individual mementos and Raintale for creating entire stories that archivists can export to a variety of formats.



There are no comments yet.


page 10

page 14

page 15

page 28

page 29

page 36

page 37

page 38

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Trying to understand the differences between web archive collections can be onerous. Thousands of collections exist jones_many_2018 , collections can contain thousands of documents, and many collections contain little metadata to assist the user in understanding their contents jones_social_2019 . How can an archivist display a sample of a collection to drive visitors to their collection or provide insight into their archived pages?

Search engines and social media platforms have settled on the card visualization paradigm, making it familiar to most users. Web storytelling is a popular method for grouping these cards to summarize a topic, as demonstrated by tools such as Storify. For this reason, AlNoamany et al. alnoamany_generating_2017 made Storify the visualization target of their web archive collection summaries. Because Storify shut down in 2018 jones_storify_2017 , we evaluated 62 alternative tools, such as Facebook, Pinboard, Instagram, Sutori, and We found that they are not reliable for producing cards from archived web pages, mementos. Thus we developed MementoEmbed jones_preview_2018 , an archive-aware service that can generate different surrogates capra_augmenting_2013 for a given memento. Currently supported surrogates include social cards, browser thumbnails (screenshots) kopetzky_visual_1999 , word clouds, and animated GIFs of the top-ranked images and sentences. MementoEmbed’s cards appropriately attribute content to a memento’s original resource separately from the archive, including both the original domain and its favicon from the memento’s time period, as well as providing a striking image, a text snippet, and a title. MementoEmbed provides an extensive API that helps machine clients request specific information about a memento. Raintale jones_raintale_2019 leverages this API to generate complete stories containing the surrogates of many different mementos.

We review why existing platforms are not reliable for storytelling with mementos, and then detail how MementoEmbed and Raintale work to solve this functionality gap.

2 Background

MementoEmbed and Raintale focus on content from web archives. Web archives attempt to capture and preserve original resources

from the web, such as web pages and their embedded images, stylesheets, and JavaScript. Each capture comes from a specific moment in time and, as such, is a version of that original resource, a

memento. Its capture datetime is its memento-datetime. Lists of mementos for a specific original resource are available as TimeMaps. For clarity in this document, the URIs that identify original resources are URI-Rs, those that identify mementos are URI-Ms, and those that identify TimeMaps are URI-Ts. The Memento Protocol van_de_sompel_rfc_2013 documents all of these concepts. The Memento Protocol also details the datetime negotiation process where a client can supply their desired datetime and URI-R to a TimeGate and receive a matching URI-M closest to that datetime.

Web archives often visualize their holdings for end users via a playback engine that attempts to reconstruct the web page and its embedded resources as closely as possible to their state at the time of capture. This playback engine often applies transformations to the page to make this possible, rewriting links to the mementos of images captured by the web archive instead of images on the live web. The engine also applies branding to each memento in the form of a banner. For analysis, however, we often want to process raw mementos jones_raw_2016 ; jones_raw_2016_2 ; raw_mementos_2017 that do not contain these augmentations.

Once these augmentations are removed, before we can perform any analysis, we still need to remove the HTML code and navigational elements, the boilerplate pomikalek_removing_2011 ; kohlschutter_boilerplate_2010 ; nwala_survey_2017 , from the web page content. With this boilerplate removed we can generate a surrogate capra_augmenting_2013 ; al_maqbali_evaluating_2010 , a small summary of the underlying document. Figure 2 displays a surrogate produced by Bing for a live web resource, and Figure 2 displays a surrogate produced for a memento from Archive-It. As shown in the Archive-It surrogate, there is little information about the resource. More than 50% of all Archive-It surrogates resemble this one jones_social_2019 , making Archive-It’s existing surrogates poor summaries of their underlying mementos.

Where a surrogate summarizes a specific document, a user can combine multiple surrogates to create a story summarizing a topic from multiple sources. AlNoamany et al. alnoamany_generating_2017 was the first to combine this storytelling technique with web archives. Figure 3 shows an example of one of her stories created by combining mementos from the Archive-It collection Boston Marathon Bombing 2013 and the now-defunct jones_storify_2017 storytelling service Storify. Unfortunately, many tools exist for storytelling with web resources, but they have issues working with mementos.

Figure 1: An example surrogate provided by the Bing search engine.
Figure 2: The surrogate used for Archive-It mementos provides the URI-R and capture dates. Other information is optional and not drawn from the underlying page, but supplied by archivists, making them each a poor, inconsistent summary of a memento.
Figure 1: An example surrogate provided by the Bing search engine.
Figure 3: An example story summarizing content from the Archive-It web archive collection Boston Marathon Bombing 2013 using the now-defunct platform Storify.

3 Problems with Combining Existing Storytelling Platforms with Web Archives

Primary Reason Unsuitable for Our Work Curation Platform
No Longer In Service Addict-o-matic, AutoEmbed, Bundlr, Google+, Kurator, Newsle, Pulse, Storify
Focus is Engaging with Customers, Not Social Media Storytelling Cision,, FlashIssue, Folloze, Sharpr, Spredfast, Sprinklr, Trap!t
Content Curation for Website Construction, Not Social Media Storytelling Curata, CurationSuite, RockTheDeadline, Roojoom, SimilarWeb, Waywire Enterprises
Social Media Aggregation and Response, Not Social Media Storytelling Hootsuite, Pluggio, PostPlanner, SproutSocial
Focus is Only on Present Content, Not Social Media Storytelling ContentGems, DrumpUp,, The Tweeted Times, Tagboard, UpContent
No Public Sharing of Content Feedly, Pinboard, Pocket, Shareist
No General URI Support Flickr, Huzzazz, Instagram, Togetter, Vidinterest
Surrogate Size Changes, Making Storytelling Difficult Flipboard, Flockler, Juxtapost, Pinterest,
No Public API BagTheWeb, ChannelKit, eLink, Listly, Pearltrees, Sutori, Symbaloo
No Reliable Surrogate Production Facebook, Twitter
Confuses Information About Memento Tumblr,, iframely, noembed, microlink
Table 1: The live web curation platforms considered as part of the 2017 review in Section 3 and the reasons as to why they are unsuitable for our storytelling efforts., iframely, noembed, microlink were added in 2019.

In 2017, we examined a large number of live web curation platforms jones_where_2017 . In this section, we demonstrate why these platforms are not suitable for our storytelling efforts. Table 1 lists the tools detailed in this section and why they are unsuitable for our work. The list of tools comes from AlNoamany’s work alnoamany_using_2016 , Curata’s survey of its potential competitors hall_content_2017 , and work by Williams williams_40_2012 . This is a volatile landscape and new companies enter this space frequently. Where Table 1 provides a summary, the rest of this section provides more detail on our findings when using these tools to visualize mementos.

After this review, we came to the conclusion that many of these services would not reliably produce good surrogates for mementos. None provided the level of control AlNoamany exploited to create good surrogates with Storify alnoamany_generating_2017 . This led us to develop our own surrogate service to support our research efforts.

3.1 Engaging with Customers, Not Storytelling

Some tools exist for customer engagement. They provide the ability to curate content from the web to increase confidence in a brand. With, users can share collections internally so that teams can review these collections to craft a message. It allows an organization to curate their own content and coordinate a single message across multiple social channels. They provide social monitoring and analysis of the impact of their message. They use their curated content to develop plans for addressing trends, dealing with crises (e.g., the 2017 Pepsi commercial fiasco victor_pepsi_2017 ), and ensuring that customers know the company is a key player in the market (e.g., IBM’s Big Data & Analytics Hub curata_ibms_2014 ). Cision111, FlashIssue222, Folloze333, Spredfast444, Sharpr555, Sprinklr666, and Trap!t777 are tools with a similar focus zickelbrach_personal_2017 ; schlachter_personal_2017 . We requested demos and discussions about these tools with similar companies but only received feedback from and Spredfast who were instrumental in helping us understand this space.

Roojoom888, Curata999, and SimilarWeb101010, and Waywire Enterprises111111 focus more on helping influence the development of the corporate web site with curated content. RockTheDeadLine121212 offers to curate content on the organization’s behalf. CurationSuite131313 (formerly CurationTraffic) focuses on providing a curated collection as a component of a WordPress blog. These services go one step further and provide site integration components in addition to mere content curation.

Hootsuite141414, Pluggio151515, PostPlanner161616, and SproutSocial171717 focus on collecting and organizing content and responses from social media. They do not provide collections for public consumption in the same way Storify or a Facebook album would. Hootsuite, in particular, provides a way to gather content from many different social networking accounts at once while synchronizing outgoing posts across all of them.

All of these tools offer analytics packages that permit the organization to see how the produced newsletter or web content is performing. Though these tools do focus on curating content, their focus is customer engagement and marketing. Most of these tools focus on trends and web content in aggregate rather than showcasing individual web resources. Our focus is to find new ways of visualizing representative mementos from web archive collections. Though some of these tools might be capable of doing this, their unused excess functionality make them a poor fit for our purpose.

3.2 Only Displaying the Present

Some tools allow the user to supply a topic as a seed for curated content. The tool will then use that topic and its internal curation service to locate content that may be useful to the user. A good example is a local newspaper. A resident of Santa Fe, for example, will likely want to know what content is relevant to their city, and hence would be better served by the curation services of the Santa Fe New Mexican181818 than they would by the Seattle Times191919 The newspaper changes every day, but the content reflects the local area.

Figure 4: presents a different collection each day based on the user’s keywords. The user-created The Science Daily changes every day. The content for June 4, 2017 (left) is different from the content for June 5, 2017 (right).
Figure 5: (left) The Tweeted Times shows some of the tweets from the author’s Twitter feed. (right) Tagboard requires that a user supply a hashtag as input before creating a collection.

Geographic location is not the only limiting factor for this category of curation tools. Paper.li202020 (Figure 4) and UpContent212121 allow one to create a personalized newspaper about a given topic that changes each day, providing fresh content to the user. ContentGems222222 is much the same but supports a complex workflow system that can be edited to supply content from multiple sources. ContentGems also allows one to share their generated paper via email, Twitter, RSS feed, website widgets, RSS, IFTTT232323, Zapier242424, and a whole host of other services. DrumUp252525 uses a variety of sources from the general web and social media to generate topic-specific collections. They also allow the user to schedule social media posts to Facebook, Twitter, and LinkedIn. appears to be focused on a single user, ContentGems and DrumUp easily stretch into customer engagement, and UpContent offers different capabilities depending on to which tier the user has subscribed.

The Tweeted Times262626 and Tagboard272727 (Figure 5) both focus on content from social media. The Tweeted Times attempts to summarize a user’s Twitter feed and later publishes that summary at a URI for the end user to consume. Tagboard uses hashtags from Facebook or Twitter as seeds to their content curation system.

The tools in this section focus on content from the present. They do not allow a user to supply a list of URIs and view them as surrogates, hence are not suitable for our storytelling efforts.

3.3 Poor Sharing or No Social Cards

There is a spectrum of sharing. Storify allowed one to share their collection publicly for all to see. Other tools expect only subscribed accounts to view their collections. In these cases, subscribed accounts may be acquired for free or at cost. Feedly282828 supports the sharing of collections only for other users in one’s team, a grouping of users that can view each other’s content. Pinboard292929 and Pocket303030 are slightly less restrictive, permitting other portal users to view their content. Also, both Pinboard and Pocket promise paying customers the ability to archive their saved web resources for later viewing. Shareist313131 only shares content via email and on social media, but does not produce a web-based visualization of a collection. We are interested in tools that allow us to not only share collections of mementos on the Web but also share them with as few barriers to viewing as possible.

Huzza323232 and Vidinterest333333 only support URIs to web resources that contain video. Both support YouTube and Vimeo URIs, but only Vidinterest supports Dailymotion. Neither support general URIs, let alone URI-Ms. Instagram343434 and Flickr353535 work specifically with images, and they do not create social cards for URIs (Figure 6). As shown in Figure 7, even though Twitter may render a social card in the Tweets, the card is not present when the tweets are visualized in a collection using Togetter363636

The lack of surrogates and the limitations on sharing and media types make these tools unsuitable for our storytelling efforts.

Figure 6: An example Instagram post. Note that the links in the comment are not converted to surrogates, or even clickable text.
(a) A Tweet displaying a social card.
(b) A Togetter collection containing the Tweet from Figure 6(a).
Figure 7: Togetter is not suitable for our purposes because it does not display social cards, even though they are displayed in the Tweets making up a collection.

3.4 Confusing Story Flow

Some tools change the size of the card for effect, or to allow extra data in one card rather than another. These size changes interrupt the visual flow of the small multiples paradigm that makes storytelling successful. While good for presenting in newspapers or other tools that collect articles, such size changes make it difficult to follow the flow of events in a story. They create additional cognitive load on the user, forcing her to regularly ask “does this different sized card come before or after the other cards in my view?” and “how does this card fit into the story timeline?”

Flipboard373737 often makes the first social card the largest, dominating the collection as seen in Figure 8. Sometimes it will choose another card in the collection and increase its size as well. Flipboard also has other issues. In Figure 8, we see social cards rendered for live links, but in Figure 9 we see that Flipboard does not do so well with mementos.

Figure 8: Flipboard orders the social cards from left to right then up and down, but changes the size of some of the cards.
Figure 9: Unlike live web resources, Flipboard does not render mementos as social cards.

Scoop.it383838 (Figure 10) changes the size of some social cards due to the presence of large images or extra text in the snippet. These changes distort the visual flow of the collection. There are also restrictions, even for paying users, on the amount of content that users can store, with users being limited to only 15 collections, even though they subscribed to the top $33 per month subscription.

Figure 10: In this collection, changes the size of some social cards based on the amount of data present in the card.

Flockler393939 alters the size of its cards based on the information present. Cards with images, titles, and snippets are larger than those with just text. As shown in Figure 11, sometimes Flockler cannot extract any information and generates blank cards or cards whose title is the URI.

Figure 11: Flockler alters the sizes of some cards based on the information present. It also fails to generate cards for some mementos.

Pinterest has a distinct focus on images but does create social cards (i.e., “pins” in the Pinterest nomenclature) for web resources. The system requires a user to select an image for each pin. Unfortunately, the images are all different sizes (Figure 12), making it difficult to follow the sequence of events in the story. In addition to the size issue, if Pinterest cannot find an image in a page or if the image is too small, it will not create a surrogate. This lack of consistency means that Pinterest is not reliable enough for our storytelling efforts.

Figure 12: Pinterest supports collections, but does not typically generate social cards, favoring images as seen in this example.

Juxtapost404040 (Figure 13) is the other tool which changes the size of the social cards. Like with Pinterest, Juxtapost requires that the end user select an image and insert a description for every card.

Figure 13: As seen in this collection, Juxtapost changes the size of social cards and even moves them out of the way for advertisements (top right text says “–Advertisement–”). Which direction does the story flow?

3.5 No API

Our research for summarizing collections requires that our system generate the story automatically. We require a web API. Would it be acceptable for a human to submit these links from our solution to one of these tools? What if the collection changes frequently and our solution must be executed again to account for these changes?

Pearltrees has no API414141 We could not locate documentation of APIs for Symbaloo424242, eLink434343, ChannelKit444444, or BagTheWeb454545 Both Sutori ketchell_personal_2018 and Listly have APIs, but neither are public464646

BagTheWeb requires additional information supplied by the user in order to create a social card. BagTheWeb does not generate any social card data based solely on the URI. If there were an API, our solution might be able to address some of these shortcomings. Symbaloo is much the same. It chooses an image but often favors the favicon over an image selected from the article.

Pearltrees has problems that may be addressed by an API that allows the user to specify information. Figure 14 displays a Firefox error instead of a selected image in the social card. This image is especially surprising because the system was able to extract the title from the destination URI. Pearltrees also tends to convert URI-Ms to URI-Rs, linking to the live page instead of the memento.

Figure 14: A screenshot of two social cards created from Archive-It mementos by Pearltrees in a collection about the Boston Marathon. The one on the left displays a Firefox error instead of a selected image for the memento.
Figure 15: A screenshot of two social cards generated from Archive-It mementos from an eLink collection about the Boston Marathon Bombing. The one of the left shows a missing selected image while the one on the right displays fine.

The social cards generated by eLink have a selected image, a title, and a text snippet. Sometimes, however, eLink does not seem to find an image on the page. also has similar problems for some URIs. An API call that allows one to select an image for the card would help improve these tools’ shortcomings.

Figure 16: A screenshot of the social cards generated from Archive-It mementos in a ChannelKit collection about the Boston Marathon Bombing. The one on the right shows no useful information.
Figure 17: A screenshot of social cards generated from Archive-It mementos in a Listly collection about the Boston Marathon Bombing. The one on the top has no information but the URI. The one on the bottom contains a title, selected image, and snippet.

ChannelKit’s social cards are complete with a title, text snippet, and a selected image or web page thumbnail. Sometimes, as seen in Figure 16, the resulting card contains no information, and a human must intervene. As shown in Figure 17, Listly also has issues with some of the links submitted to it. It usually generates a title, text snippet, and selected image, but in some cases, just lists the URI. Flockler also has similar problems. An API call that allows one to supply the missing information would help address us these issues.

3.6 Poor Performance From Remaining Platforms

With 2.2 billion users disparte_facebook_2018 , Facebook is the most popular social media tool. Facebook supports social cards in posts and comments. Facebook also supports creating albums of photos, but not of posts. Posts contain comments, however. In order to generate a series of social cards in a collection, we gave the post the title of the collection and supplied each URI-M in the story to a separate comment, as seen in Figure 18. In this way, we can generate a story.

Figure 18: Selected mementos from Archive-It collection 3649 about the Boston Marathon Bombing as visualized in social cards in Facebook comments where the collection is stored as a Facebook post.
Figure 19: A screenshot of two Facebook comments. The URI-M below generated a social card, but the URI-M above did not.

As seen in Figure 19, Facebook does occasionally fail to generate social cards for links. The Facebook API474747 could be used to update such comments with a photo and a snippet, if necessary. Providing additional images is not possible, as Facebook posts and comments will not generate a social card if the post/comment already has an image. To ensure that we maximize the social card capability of Facebook, we have two options. We can generate all text snippets and select images ourselves for each memento. Alternatively, we could test to see which URI-Ms fail to produce a social card. In the case of either, we would be generating surrogates ourselves and not really using Facebook for anything more than a publishing medium.

(a) We must manually upload our own photo for this Twitter Moment
(b) Tweets in the Twitter Moment do not render cards for our Archive-It URI-Ms
Figure 20: This Twitter Moment contains tweets that contain the URI-Ms from our Dark and Stormy Archives summary.

While all tools required that the user title the story in some way, as shown in Figure 19(a), Twitter Moments requires that the user upload an image separately in order to create a story. This image serves as the striking image for the story. The user is also compelled to supply a description. Sadly, much like Flipboard, Twitter Moments does not appear to generate social cards for URI-Ms. Shown in Figure 19(b), Twitter Moments display URI-Ms with no additional visualization.

For those tweets that fail to produce social cards, we could use the Twitter API to add images and additional text (up to 280 characters of course) to supplement these tweets. At that point, we are building our own social cards out of tweets and just using Twitter as a publishing medium, just like we would be if we had to work around Facebook’s reluctance to produce social cards in some cases. We will highlight how Raintale accomplishes this in Section 5.

3.7 Confusing Archive Data With Content

The examples in this section will demonstrate some embeds using a memento of CNN Blogs from 2011 preserved by Archive-It, shown in Figure 21.

Figure 21: This is a screenshot of the example CNN memento used in section 3.7. Its memento-datetime is February 11, 2011, at 7:22:57 GMT and Archive-It has preserved it. This page was selected because it contains substantial content, including images.

In 2019, we reviewed Tumblr,, embed.rocks484848, Iframely494949, noembed505050, microlink515151, and autoembed525252 As of this writing, the autoembed service appears to be gone. The noembed service only provides embeds for a small number of web sites and does not support web archives. Iframely responds with errors for memento URIs, as shown in Figure 22. Microlink produces output for some mementos, but not our CNN example.

Figure 22: What the Iframely parsers see for the Figure 21 according to their web application.

Tumblr,, and are the only services that produce output for our example memento. Unfortunately, none of these services are fully archive-aware. One of the goals of a good surrogate is to convey some level of aboutness for the underlying web resource. Mementos are documents with their own topics. They are typically not about the archives that contain them. Intermixing these two concepts of document content and archive information, without clear separation, produces surrogates that can confuse users. The service is not archive-aware. The example in Figure 23 shows an embed that fails to convey the aboutness of its underlying memento, appearing to attribute this CNN article to Figure 24 demonstrates that Tumblr has the same issues. What is the resource behind this surrogate really about? This mixing of resources weakens the surrogate’s ability to convey the aboutness of the memento.

Figure 23: The social card does not fare much better, attributing Figure 21’s CNN page to produces a much more attractive card but still falls short. In Figure 25 we see an embed created for the same resource. It contains the title of the resource as well as a short description and even a striking image from the memento itself. Unfortunately, it contains no information about the original resource, potentially implying that someone at is serving content for CNN. Even worse, in the world where readers are concerned about fake news, this surrogate may lead an informed reader to believe that this is a link to a counterfeit resource because it does not come from

Figure 24: Tumblr cards misattribute content to web archives rather than their original source. Is this fake news?
Figure 25: This screenshot of an embed for the Figure 21’s CNN memento shows how well performs. While the image and description convey more aboutness for the original resource, the memento is attributed to Archive-It with CNN’s favicon. Did CNN or Archive-It create this content? Should the reader be suspicious?

4 Creating Surrogates With MementoEmbed

Because of the issues detailed in the last section with existing platforms, we developed MementoEmbed to produce surrogates for mementos. MementoEmbed is the first archive-aware embeddable surrogate service, meaning it can include memento-specific information such as the memento-datetime, the archive from which a memento originates, and the memento’s original resource domain name. Figure 26 displays a social card generated by MementoEmbed. As demonstrated in Figure 27, this card separates information derived from the memento content from information about the archive containing it. Through the Memento Protocol, MementoEmbed can attribute this content to its original web site, avoiding the confusion produced by other services, further allowing a user to understand the nature of the web page behind the surrogate.

Figure 28 demonstrates how a user can create their own cards. In Figure 27(a), the user enters the memento’s URI-M and selects their desired surrogate type. MementoEmbed responds with a surrogate as shown in Figure 27(b). In addition to creating the surrogate, MementoEmbed also provides the user with code they can copy to embed the surrogate into their web page or blog.

Figure 26: A social card generated by MementoEmbed based on the memento in Figure 21.
Figure 27: Because it is archive aware, the MementoEmbed social card avoids the misattribution caused by other services.
(a) A user inserts a URI-M and selects their desired surrogate.
(b) MementoEmbed displays the surrogate on the left and its associated HTML on the right.
Figure 28: The MementoEmbed User Interface.

4.1 MementoEmbed Surrogate Types

MementoEmbed currently generates the following surrogate types:

  • social cards (Figure 26)

  • browser thumbnails (Figure 31)

  • imagereels (Figure 31) – animated GIFs of the top five images

  • word clouds (Figure 31)

  • docreels (Figure 32) – animated GIFs of the top five images and top ranked sentences.

Working with web archives, we are acutely aware of how resources can disappear over time. We acknowledge that a user’s web page may outlive the MementoEmbed instance from which they generated their surrogate. For this reason, the embeddable HTML code contains data URIs for all surrogate types but social cards, removing the requirement that the MementoEmbed service host images for other web pages.

MementoEmbed’s documentation mementoembed_docs details how to install and configure it. The following sections provide detail on the available surrogates and how MementoEmbed generates them.

4.1.1 Social Card

MementoEmbed social cards, as seen in Figure 26, contain various pieces of information intended to summarize the resource:

  • title

  • description

  • striking image

  • containing archive

  • archive favicon

  • original resource domain

  • original resource favicon

  • memento-datetime

  • a link to the original resource, if still present

  • a link to help readers discover other mementos of this resource

MementoEmbed uses the Memento Protocol to detect if the given URI-M identifies a memento. If so, it uses its knowledge of web archive URI patterns to discover the raw memento for the given URI-M. It then processes this raw memento to discover its title and description.

To discover a memento’s title, MementoEmbed does the following with the raw memento’s content:

  1. search for HTML META elements containing any of the following keys and save their values:

    • og:title

    • twitter:title

  2. if a value for og:title is present, return that value

  3. if a value for twitter:title is present, return that value

  4. if no title has been found from this existing social media metadata, extract the text from the HTML TITLE element on the page and return it

  5. if no title has been found, return an empty string

To discover a memento’s description, MementoEmbed does the following with the raw memento’s content:

  1. search for HTML META elements containing any of the following keys and save their values:

    • og:description

    • twitter:description

  2. if a value for og:description is present, return that value

  3. if a value for twitter:description is present, return that value

  4. if no description has been found from this existing social media card metadata:

    1. remove boilerplate from the HTML

    2. return the first 197 characters of the content, followed by an ellipsis if the last character is not punctuation

  5. if no description has been found, return an empty string

To discover a memento’s striking image, MementoEmbed uses the augmented memento’s content rather than the raw memento’s content. We want our card to contain an image from the web archive and not the live web. The augmented memento has rewritten URIs for its images and will ensure that MementoEmbed only processes images that have been archived. It uses the following process to discover images:

  1. search for HTML META elements containing any of the following keys and save their values:

    • og:image

    • twitter:image

    • twitter:image:src

    • image

  2. if a value for og:image is present, is a memento, and its URI-M returns a 200 HTTP status, return that value

  3. if a value for twitter:image is present, is a memento, and its URI-M returns a 200 HTTP status, return that value

  4. if a value for twitter:image:src is present, is a memento, and its URI-M returns a 200 HTTP status, return that value

  5. if a value for image is present, is a memento, and its URI-M returns a 200 HTTP status, return that value

  6. if no image URI has been found from this existing social media metadata:

    1. extract all image URIs from the SRC attribute of IMG HTML elements

    2. extract all image URIs from the SRCSET attribute of IMG HTML elements

    3. for each image URI:

      1. if URI does not identify a memento, use datetime negotation to discover a memento of the image, if possible

      2. download the corresponding image and calculate terms for the scoring equation, as described below

    4. select the highest scoring image

  7. if no image has been found, return the default image of a wireframe globe

The goal of image selection is to discover an image quickly. Thus, MementoEmbed does not use external services like Google’s Vision API535353 or Amazon Rekognition API545454 to analyze images. With no pre-existing knowledge of the memento, the system attempts to use easily discoverable image features to score each image with Equation 1


where is the number of images in the HTML, is the image position as discovered in the HTML, is the image size in pixels as width height, is the number of columns in the image histogram where the value is 0, is the ratio of image width to height, and is the number of colors in the image. The terms through are weights applied to these features’ raw values. Through trial and error, we have discovered that the most desirable images occur earlier in the page (low ), are larger (high ), have less negative space (low ), are less likely to look like a rectangular banner (low ), and are colorful (high ). Thus, we optimized the equation for these attributes.

MementoEmbed generates the containing archive name by extracting the registered domain name from the URI-M and making it upper case. We decided it best to present the domain name to users rather than matching domain names to organizational names for a few reasons. Organizations have different names in different languages. Organizations may change their names over time. The registered domain name is a sufficient form of identification, promotes the archive, and allows the reader to discover more about the archive through this link.

For additional archive branding, we discover the web archive’s favicon and apply it to the card. To discover this, MementoEmbed employs the following algorithm:

  1. extract the domain name and scheme from the URI-M to discover the web archive’s home page

  2. visit this home page

  3. analyze the HTML in the home page to find the favicon in the LINK element’s icon, shortcut, or shortcut icon relations – return this value if present

  4. if no valid favicon, construct the URI of the favicon by appending favicon.ico to the web archive’s home page URI – if this URI resolves, return this value

  5. if no valid favicon thus far, then consult the Google Favicon service555555[INSERTURI] using the web archive’s domain name as the input parameter

While downloading a memento, MementoEmbed extracts the URI-R and memento-datetime from the headers provided by the Memento Protocol. It applies the URI-R and memento-datetime to the card. It parses the URI-R to discover the original resource domain name. We discover the original resource favicon with the following algorithm:

  1. analyze the HTML in the memento to find the favicon in the LINK element’s icon, shortcut, or shortcut icon relations

  2. if this value is present

    1. verify that it is a memento, if so, return it

    2. if not, use datetime negotiation to discover a memento of this URI

    3. if a memento of this URI is present, return its URI-M

  3. if MementoEmbed has not discovered a favicon thus far, construct the URI of the favicon by appending favicon.ico to the orignal resource domain URI and perform datetime negotiation to find its URI-M – if this URI-M resolves, return

  4. if no URI-M for this favicon, then test that the URI-R exists, and if so, return that URI-R if it returns an HTTP 200 status code

  5. if MementoEmbed has not discovered a favicon, then consult the Google Favicon service565656[INSERTURI] using the original resource’s domain name as the input parameter

MementoEmbed provides a link to other mementos through the Los Alamos National Laboratory’s Memento Aggregator Time Travel service575757 To build the link, MementoEmbed appends the memento datetime and the URI-R to the Aggregator’s API – e.g., for the memento in Figure 21 it generates

Users can control the creation of this social card with several advanced options. They can convert the striking image and favicons to data URIs masinter_rfc_1998 , thus ensuring that their card will be unaffected by issues with the web archive containing these mementos. By default, MementoEmbed cards require a JavaScript library that is hosted with the MementoEmbed instance. To avoid dependencies on the MementoEmbed service, the user can select an option that will generate a card without any dependency on this JavaScript library.

Figure 30: The five images that make up MementoEmbed’s imagereel created from Figure 21’s memento. The imagereel starts black and fades to an image before returning back to black and fading to another image. The full animated GIF contains 105 frames.
Figure 29: A browser thumbnail generated by MementoEmbed based on the memento in Figure 21.
Figure 30: The five images that make up MementoEmbed’s imagereel created from Figure 21’s memento. The imagereel starts black and fades to an image before returning back to black and fading to another image. The full animated GIF contains 105 frames.
Figure 31: A word cloud generated by MementoEmbed based on the memento in Figure 21.
Figure 29: A browser thumbnail generated by MementoEmbed based on the memento in Figure 21.
Figure 32: The five images and five sentences that make up MementoEmbed’s docreel created from Figure 21’s memento. The docreel starts black and fades in an image or sentence before fading back to black.

4.1.2 Browser Thumbnail

To produce a browser thumbnail as shown in Figure 31, MementoEmbed uses Puppeteer585858 to load the URI-M in a headless version of Google Chrome and capture a screenshot. Users have the option to change the height and width of the thumbnail. They can also alter the viewport size of the headless browser. They can specify a timeout for MementoEmbed to stop trying if the thumbnail takes an excessive amount of time to generate. They can also ask MementoEmbed to remove a web archive’s banner from the thumbnail. This last option is only available for web archives that support separate URI-Ms that do not contain this banner.

4.1.3 Imagereel

MementoEmbed can produce a new type of surrogate we refer to as the imagereel. Imagereels are animated GIFs containing a fixed number of images extracted from the underlying memento. MementoEmbed orders the images by their descending Equation 1 score. MementoEmbed then applies a fading effect to each image, creating frames where the image fades from black to the full image and back to black again. MementoEmbed then arranges these frames so that the resulting imagereel displays each image fading in and out. As print documents cannot display animated GIFs, in Figure 31, we instead display the non-faded frames of the imagereel produced from the memento from Figure 21.

The default number of images is five. A user can change the width and height of the imagereel, the duration of each frame, and the number of images to include. Imagereels are only really practical for mementos that contain many images, thus limiting their use. They can be combined with other content in a blog post to feature a variety of images in a smaller space, similar to the carousel pernice_2013 present on many modern web pages. They can also be used in a social media post to provide a large number of images in a small space.

4.1.4 Word Cloud

Word clouds 10.1145/1374489.1374501 are commonly used to convey the meaning of documents by displaying words in sizes proportional to their frequency. MementoEmbed leverages the wordcloud wordcloud_python Python library to produce word clouds from the memento, as shown in Figure 31. Word clouds are a newer addition to MementoEmbed. They are not yet configurable via the graphical user interface but are configurable via the API covered in Section 4.2.

4.1.5 Docreel

MementoEmbed also includes a second new type of surrogate we refer to as the docreel. Like imagereels, docreels are animated GIFs. In addition to the top-scoring images in the memento, docreels include the memento’s top-scoring sentences. The images are scored using Equation 1 and the sentences are scored by the ARC90 readability andreasvc_python algorithm. In addition to the images and sentences, MementoEmbed overlays the original domain names, archive domain names, favicons, and the memento-datetime onto each frame. Again, as with imagreels, the images and sentences fade in and out. Figure 32 displays ten non-faded frames from an example docreel. Docreels are experimental, can take more than five minutes to generate, and the browser may timeout before MementoEmbed completes their generation. They are not currently configurable by users.

4.2 Web API

We developed MementoEmbed’s API in concert with its user interface. Originally, our goal with the API was to allow the user interface to make multiple simultaneous requests to improve response times. It has evolved into a more general-purpose memento information and visualization tool. This section will only provide an overview of the API. For more detailed and current information consult the documentation mementoembed_api_docs . The two main branches of the MementoEmbed web API are:

  • /services/memento - for getting specific information about a memento, detailed in Table 2 in Appendix A

  • /services/product - for directly producing a surrogate through one of the following:

    • /services/product/socialcard/

    • /services/product/thumbnail/

    • /services/product/imagereel/

    • /services/product/wordcloud/

    • /services/product/docreel/

Clients request information by choosing the appropriate endpoint and appending the URI-M to that endpoint. Each endpoint responds with a JSON object containing fields and data about that particular aspect of the memento. For example, Figure 33 displays the JSON response for the URI-M submitted to the /services/memento/contentdata/ endpoint. Every endpoint returns the fields urim and generation-time by default. The contentdata endpoint provides the additional fields of title and snippet drawn from the content of the memento. Other endpoints have their own fields for providing additional memento data, as listed in Table 2 of Appendix A.

  "urim": "",
  "generation-time": "2020-04-20T22:59:52Z",
  "title": "Blast Theory",
  "snippet": "Sam Pearson and Clara Garcia Fraile are in residence for one month Sam Pearson and Clara Garcia Fraile are in residence for one month working on a new project called In My Shoes. They are developin...",
  "memento-datetime": "2009-05-22T22:12:51Z"
Figure 33: Example output from MementoEmbed’s /services/memento/contentdata/ API endpoint
  "urim": "",
  "processed urim": "",
  "generation-time": "2020-04-20T23:01:00Z",
  "images": {
      "": {
          "source": "body",
          "content-type": "image/jpeg",
          "is-a-memento": true,
          "magic type": "JPEG image data, JFIF standard 1.02, aspect ratio, density 100x100, segment length 16, progressive, precision 8, 168x96, components 3",
          "imghdr type": "jpeg",
          "format": "JPEG",
          "mode": "RGB",
          "width": 168,
          "height": 96,
          "blank columns in histogram": 463,
          "size in pixels": 16128,
          "ratio width/height": 1.75,
          "byte size": 1979,
          "colorcount": 4776,
          "pHash": "f771185c8c86c667",
          "aHash": "00008085f7ffffff",
          "dHash_horizontal": "0c1b4b0d0d2c2c4d",
          "dHash_vertical": "cbf7ffffffffffff",
          "wHash": "00008080e7ffffff",
          "N": 14,
          "n": 11,
          "k1": 0.1,
          "k2": 0.4,
          "k3": 10,
          "k4": 0.5,
          "k5": 10,
          "calculated score": 49580.625
      ... other records omitted for brevity ...
  "ranked images": [
Figure 34: Some example output from the /services/memento/imagedata/ API endpoint

The MementoEmbed API uses the following HTTP status codes to indicate success or error:

  • 200 - all was successful

  • 400 - the submitted URI is invalid, either lacking a scheme or otherwise not formed according to standards

  • 404 - the submitted URI does not identify a memento, and MementoEmbed cannot service it

  • 500 - any error not covered elsewhere

  • 502 - while requesting the URI-M for processing, there was a connection issue with the web archive

  • 504 - while requesting the URI-M from the archive for processing, the connection timed out

Because page content varies, some endpoints provide far more information than is detailed in Table 2 of Appendix A. For example, Figure 34 shows the wealth of information available for images discovered in the memento, including content-type, pixel size, perceptive hash (pHash), details of the weights used in the scoring equation, and much more. Developers who wish to use the API should consult the full API documentation mementoembed_api_docs for more details on what sub-fields are available for pages where the output fields vary based on the memento, such as the the imagedata, seeddata, paragraphrank, setencerank, and page-metadata endpoints.

Clients can alter the behavior of some endpoints via the Prefer snell_rfc_2014 HTTP request header. For example, the default width of thumbnails is 208 pixels with a viewport width of 1024 pixels. If a client desires a thumbnail 2048 pixels wide with a viewport of 4096 pixels wide, they specify these values in the Prefer header as shown in 34(a). In Figure 34(b), the server uses the Preference-Applied response header to list the values of all preferences used when generating the resulting thumbnail. Figure 3 provides a list of all endpoints and their available preferences.

The user interface is a client of the API. We did not employ specialized logic generate surrogates differently in the API compared to the user interface. We developed MementoEmbed with the intention that the API would be used by a variety of clients to gather information on individual mementos. Raintale is one such client. We developed Raintale for telling stories with many mementos.

GET /services/product/thumbnail/ HTTP/1.1
User-Agent: curl/7.54.0
Accept: */*
Prefer: viewport_width=4096,thumbnail_width=2048
(a) The request specifies these options as part of the Prefer header.
HTTP/1.0 200 OK
Content-Type: image/png
Content-Length: 437589
Preference-Applied: viewport_width=4096,viewport_height=768,thumbnail_width=2048,thumbnail_height=156,timeout=60
Server: Werkzeug/0.14.1 Python/3.6.5
Date: Wed, 25 Jul 2018 20:59:21 GMT
...437589 bytes of data follow...
(b) The response indicates which preferences were applied via the Preference-Applied header.
Figure 35: HTTP request and response with the web API for a browser thumbnail with a viewport width of 4096 pixels and a thumbnail width of 2048 pixels.

5 Telling Stories From Web Archives With Raintale

Where MementoEmbed focuses on a single memento, Raintale provides stories created from multiple mementos. It accepts two forms of input: a list of URI-Ms and a template. The template formats the output and contains variables that indicate what information the user wishes to display for each memento. Figure 36

demonstrates the relationship between MementoEmbed and Raintale. In step 1, the user provides a template and a list of URI-Ms to Raintale. In step 2, Raintale records all template variables. For each provided URI-M, Raintale consults MementoEmbed’s API for each variable’s value in the corresponding memento. In step 3, MementoEmbed downloads the memento from its web archive and performs natural language processing, image analysis, or extracts information via the Memento Protocol

van_de_sompel_rfc_2013 , as appropriate to the API request. In step 4, Raintale consolidates the data from these API responses and renders the template with the gathered data. It produces a story constructed from surrogates and other supplied content (e.g., story title, collection metadata).

Raintale is currently a command-line application that provides various options for the end user. To create a story using the mementos supplied in story-mementos.txt and a template file mytemplate.tmpl and save the output to mystory.html, a user would type the following.

  # tellstory -i story-mementos.txt --storyteller template --story-template mytemplate.tmpl -o mystory.html --title "This is My Story Title"

We designed Raintale this way so that users can easily integrate it into shell scripts with other utilities, such as Hypercane jones_hypercane_2020_1 ; jones_hypercane_2020_2 ; jones_hypercane_2020_3 , that can provide it a list of mementos or an automated utility that might produce different templates for different use cases. We intend for Raintale to be part of an automated web archiving workflow, and we provide features that allow the archivist to customize its output to their needs.

Raintale supports different types of storytellers. File storytellers, such as template or html save content to a file. Service storytellers, such as twitter or facebook, write content to a specifc social media service. A user can apply templates to different types of storytellers. Instead of supplying their own template, a Raintale user can apply one of its pre-packaged presets. On pages 37 to 44, Figures 37 to 44 display examples applying these presets for mementos from the Archive-It collection Occupy Movement 2011/2012. Internally, a template exists for each of these and Raintale processes this pre-package template rather than requiring that the user supply their own.

For file storytellers, as demonstrated in Figures 37, 38, 39, 40, 43, and 44, Raintale requires that the user supply the name of the output file. The following command generates a story with the preset HTML storyteller and the URI-Ms listed in the file story-mementos.txt and writes the output to a file named mystory.html.

# tellstory -i story-mementos.txt --storyteller html -o mystory.html --title "This is My Story Title"

For service storytellers, such as Twitter (Figure 41), the user must supply a YAML file containing the appropriate credentials to use that service. The command below generates a story with the preset Twitter storyteller and the URI-Ms listed in the file story-mementos.txt and writes the output as a Twitter thread using the credentials specified in twitter-credentials.yml.

# tellstory -i story-mementos.txt --storyteller twitter --title "This is My Story Title" -c twitter-credentials.yml
Figure 36: The MementoEmbed-Raintale Architecture for Storytelling
Figure 37: Raintale output examples - HTML with social cards
Figure 38: Raintale output examples - HTML with social cards created via Bootstrap
Figure 39: Raintale output examples - 3 column HTML story of thumbnails
Figure 40: Raintale output examples - 4 column HTML story of thumbnails
Figure 41: Raintale output examples - Twitter thread
Figure 42: Raintale output examples - Facebook post
Figure 43: Raintale output examples - MediaWiki markup published to a MediaWiki article
Figure 44: Raintale output examples - Markdown in a GitHub gist
Figure 45: A text input file for Raintale
Figure 46: How Raintale combines the template and the story file to insert memento data into the desired output
    "title": "My Story Title",
    "collection_url": "",
    "generated_by": "My Curator",
    "metadata": {
        "myKey1": "value1",
        "my-Key2": "value2",
        "my key 3": "value 3"
    "elements": [
            "type": "text",
            "value": "Livestream from Oakland which remains hot, gas canisters used, arrests, warnings now about more arrests.  \"Chemical agents will be used.\""
            "type": "link",
            "value": ""
            "type": "text",
            "value": "For Shame: Hundreds Of Arrests Across the Country Today"
            "type": "link",
            "value": ""
Figure 47: A JSON input file for Raintale
1    <p><h1>{{ title }}</h1></p>
3    {% if generated_by is not none %}
4    <p><strong>Story By:</strong> {{ generated_by }}</p>
5    {% endif %}
7    {% if collection_url is not none %}
8    <p><strong>Collection URI:</strong> <a href="{{collection_url}}">{{ collection_url }}</a></p>
9    {% endif %}
11    <hr>
13    <table border="0">
14    <tr>
15    {% for element in elements %}
17    {% if element.type == link %}
19        <td><a href="{{element.surrogate.urim}}"><img src="{{element.surrogate.thumbnail|preferremove_banner=yes}}"></a></td>
21        {% if loop.index is divisibleby 4 %}
22            </tr><tr>
23        {% endif %}
25    {% else %}
27    <!-- Element type {{ element.type }} is unsupported by the thumbnails4col template -->
29    {% endif %}
31    {% endfor %}
32    </table>
Figure 48: An example Raintale template for the story shown in Figure 40
3{{ title }}
5{% if generated_by is defined %}Story By: {{ generated_by }}{% endif %}
7{% if collection_url is defined %}{{ collection_url }}{% endif %}
10{{ element.surrogate.title }}
12{{ element.surrogate.memento_datetime }}
14{{ element.surrogate.urim }}
17{{ element.surrogate.thumbnail|prefer thumbnail_width=1024,remove_banner=yes }}
18{{ element.surrogate.image|prefer rank=1 }}
19{{ element.surrogate.image|prefer rank=2 }}
20{{ element.surrogate.image|prefer rank=3 }}
Figure 49: An example Raintale template for the Twitter story shown in Figure 40

Raintale accepts two inputs: a story file containing URI-Ms and a template (or preset specification). The story file can take two forms, depending on the needs of the user.

The simplest story file format is a newline-separate text file containing URI-Ms. Figure 45 demonstrates an example. A Raintale user applying this format must supply a title to their story via the --title command-line argument, as shown below.

# tellstory -i story-mementos.txt --storyteller html -o mystory.html --title "This is My Story Title"

Where the story file contains the URI-Ms and the values of some of the template variables, the Raintale template controls the formatting and which information Raintale will request and display for each URI-M. Figure 46 demonstrates a simplified example of how this works. Raintale first consumes the template file and determines which variables exist. At this point in the template, Raintale encounters HTML formatting and the Raintale variable element.surrogate.title. Raintale uses its internal mapping to discover that the appropriate MementoEmbed API endpoint for element.surrogate.title is /services/memento/contentdata. Then Raintale iterates through all elements in the story file. When it reaches, Raintale appends the current URI-M ( to /services/memento/contentdata and submits an HTTP request to MementoEmbed. It then extracts the title from MementoEmbed’s JSON output and applies it to the resulting output file for the story.

Often users will want to specify more information for their stories than is possible with the newline-separated text file. For these use cases, they can supply a JSON formatted story file, as shown in Figure 47. This JSON format allows the user to provide additional values that can be processed by the Raintale template engine. In Figure 47, the elements key provides the list of items to include in the story. Each element of type link refers to a URI-M that Raintale will expand into a surrogate based on the template. Each element of type text contains a string that Raintale will insert into the story. Additionally, outside of the elements list, users can supply additional variables, such as generated_by, that Raintale will apply to the corresponding variable in the template. In this case, Raintale users do not need to specify a value for the --title argument.

  # tellstory -i story-data.json --storyteller html -o mystory.html

Figure 48 displays a more complex template that will produce the output shown in Figure 40. On line 1, the {{ title }} will be replaced with the title specified by the end user. The same will occur for the values of generated_by and collection_url on lines 4 and 8. On line 15, Raintale starts iterating through the list of story elements. On line 19, it will replace each element.surrogate.urim with the URI-M at that point in the iteration. On that same line, it will replace element.surrogate.thumbnail with a thumbnail generated by MementoEmbed for that same URI-M. The prefer remove_banner=yes requests that the resulting thumbnail not contain a web archive’s branding banner, a MementoEmbed preference. From this example we not only see how the variables are turned into formatted data, but also how a template writer can apply the MementoEmbed preferences listed in Table 3 of Appendix B to customize their story.

Raintale handles social media posts differently than file outputs. It assumes that social media stories will take the form of a single post, followed by comments. Figure 49 contains a Raintale multipart template used to generate the Tweets shown in Figure 41. This template consists of three parts. The RAINTALE TITLE PART contains the variables and formatting of the first post in the Twitter thread. In this case, the first post consists of the story title, who or what generated the selection of mementos for this story, and the URI of the collection containing these mementos. The RAINTALE ELEMENT PART contains the variables and formatting of the response posts of the Twitter thread, here the title, memento-datetime, and URI-M of each memento. Twitter will turn the URI-M into a clickable link. Finally, the RAINTALE ELEMENT MEDIA section contains the media that Raintale will include in each response post. This last section will instruct Raintale to upload the thumbnail generated by MementoEmbed, and the top three scoring images from the memento. When using such templates for social media, we must consider the limitations of various social media services, such as Twitter’s restrictions of four images per tweet and 280 characters of text. Raintale may partially post a story to Twitter if one of the tweets in the story fails to account for one of these restrictions.

Table 4 of Appendix B contains a list of variables that Raintale users can include in their own templates. Through these variables and their own formatting, Raintale template authors can effectively generate their own surrogates. Recall from Section 3.7 that memento surrogates need special consideration to avoid misleading users. Also, while social media services require specific storytellers, Raintale’s file output formats are not limited to HTML or Markdown. Any text-based singular file format can be supported, like JSON, XML, or CSV, making it quite valuable for a variety of automated workflows.

Raintale also supports an experimental video storytelling output inspired by the MementoEmbed docreel. Where the docreel represents a single document, this video fades in sentences and images from multiple documents. When deciding which content to include in the video, Raintale leverages the scores of the images and sentences provided by MementoEmbed. A user can create one of these videos when they wish to feature a small sample of a collection in a single social media post.

6 Future Work

Many potential directions exist for these tools. We can expand MementoEmbed’s API to include summarization by more algorithms than Readability, JusText, Lede3, and TextRank. We may apply the sumy Python library

sumy_python to introduce other automatic extractive summarization algorithms like LexRank erkan2004lexrank , Luhn luhn_automatic_1958 , Edmundson 10.1145/321510.321519 , Latent Semantic Analysis steinberger2004using , SumBasic vanderwende2007beyond , or Kullback-Lieber (KL) Sum haghighi-vanderwende-2009-exploring . To assist with this text analysis, we might also allow API clients to specify their desired boilerplate removal method. We are currently exploring better image scoring and selection techniques than Equation 1.

Raintale has the potential to be a story development tool that can support multiple external APIs. We can add new Raintale variables for querying CarbonDate 10.1145/2487788.2488121 , Memento Damage brunelle_not_2015 , and other web archive APIs. Raintale is currently a command-line application but would benefit from a GUI for easier use. Finally, we intend to include additional output options. We have explored, but not yet implemented, direct publishing to Blogger, GitHub, MediaWiki, Instagram, Tumblr, and Pinterest. Raintale could also conceivably create output in PowerPoint or PDF for sharing memento information in places outside of the Web.

7 Conclusions

We introduced MementoEmbed for generating surrogates for single mementos and Raintale for generating complete stories of memento sets. We envision Raintale and MementoEmbed to be critical components for summarizing collections of archived web pages through visualizations familiar to general users. We developed MementoEmbed so that its API is easily usable by machine clients. Raintale is a client of MementoEmbed that allows archivists to generate complete stories for lists of mementos. As a command-line application, archivists can incorporate Raintale into existing automated archiving workflows. Archivists can leverage this form of storytelling to highlight a specific subset of mementos from a collection. They can advertise their holdings, feature specific perspectives, focus on individual mementos, or help users decide if a collection meets their needs.


  • (1) Al Maqbali, H., Scholer, F., Thom, J., and Wu, M. Evaluating the Effectiveness of Visual Summaries for Web Search. In Proceedings of the 15th Australasian Document Computing Symposium (Melbourne, Australia, 2010), pp. 1–8.
  • (2) AlNoamany, Y. Using Web Archives to Enrich the Live Web Experience Through Storytelling. PhD thesis, Old Dominion University, Norfolk, VA, USA, 2016.
  • (3) AlNoamany, Y., Weigle, M. C., and Nelson, M. L. Generating Stories From Archived Collections. In WebSci 2017 (Troy, New York, 2017), pp. 309–318.
  • (4) Belica, M., 2020.
  • (5) Brunelle, J. F., Kelly, M., SalahEldeen, H., Weigle, M. C., and Nelson, M. L. Not all mementos are created equal: measuring the impact of missing resources. International Journal on Digital Libraries 16, 3-4 (2015), 283–301.
  • (6) Capra, R., Arguello, J., and Scholer, F. Augmenting web search surrogates with images. In Proceedings of the 22nd ACM international conference on Information & Knowledge Management (San Francisco, California, USA, 2013), ACM Press, pp. 399–408.
  • (7) Curata. IBM’s Big Data and Analytics Group Relies on Curata to., 2014.
  • (8) Disparte. Facebook And The Tyranny Of Monthly Active Users. Forbes (2018).
  • (9) Edmundson, H. P. New methods in automatic extracting. J. ACM 16, 2 (Apr. 1969), 264–285.
  • (10) Erkan, G., and Radev, D. R. Lexrank: Graph-based lexical centrality as salience in text summarization.

    Journal of artificial intelligence research 22

    (2004), 457–479.
  • (11) Haghighi, A., and Vanderwende, L. Exploring content models for multi-document summarization. In Proceedings of Human Language Technologies: The 2009 Annual Conference of the North American Chapter of the Association for Computational Linguistics (Boulder, Colorado, June 2009), Association for Computational Linguistics, pp. 362–370.
  • (12) Hall, M. Content Curation Tools: The Ultimate List., April 2017.
  • (13) Hunter, J., Dale, D., Firing, E., Droettboom, M., and the Matplotlib development team. Choosing Colormaps in Matplotlib., 2020.
  • (14) Jones, S., Nelson, M., and Van de Sompel, H. Mementos in the Raw., 2016.
  • (15) Jones, S. M. Storify will be gone soon, so how do we preserve the stories?, 2017.
  • (16) Jones, S. M. Where Can We Post Stories Summarizing Web Archive Collections?, Aug. 2017.
  • (17) Jones, S. M. A Preview of MementoEmbed: Embeddable Surrogates for Archived Web Pages., 2018.
  • (18) Jones, S. M. Raintale – A Storytelling Tool For Web Archives., 2019.
  • (19) Jones, S. M. Hypercane part 1: Intelligent sampling of web archive collections., 2020.
  • (20) Jones, S. M. Hypercane part 2: Synthesizing output for other tools., 2020.
  • (21) Jones, S. M. Hypercane part 3: Building your own algorithms., 2020.
  • (22) Jones, S. M. MementoEmbed 0.2020.05.08.220018 documentation., 2020.
  • (23) Jones, S. M. Web API – MementoEmbed 0.2020.05.08.220018 documentation., 2020.
  • (24) Jones, S. M., Nwala, A., Weigle, M. C., and Nelson, M. L. The Many Shapes of Archive-It. In Proceedings of the 15th International Conference on Digital Preservation (Boston, Massachusetts, USA, 2018), pp. 1–10.
  • (25) Jones, S. M., Weigle, M. C., and Nelson, M. L.

    Social Cards Probably Provide For Better Understanding Of Web Archive Collections.

    In In Conference on Information and Knowledge Management (CIKM) 2020 (Beijing, China, 2019), pp. 2023–2032.
  • (26) Ketchell, T. Personal Communication, January 2018.
  • (27) Kohlschütter, C., Fankhauser, P., and Nejdl, W. Boilerplate detection using shallow text features. In Proceedings of the 3rd ACM International Conference on Web Search and Data Mining (New York, New York, USA, 2010), ACM Press, pp. 441–450.
  • (28) Kopetzky, T., and Mühlhäuser, M. Visual preview for link traversal on the World Wide Web. Computer Networks 31, 11-16 (1999), 1525–1532.
  • (29) Luhn, H. P. The Automatic Creation of Literature Abstracts. IBM Journal of Research and Development 2, 2 (1958), 159–165.
  • (30) Masinter, L. RFC 2397 - The “data” URL scheme., 1998.
  • (31) Mueller, A. WordCloud for Python documentation., 2020.
  • (32) Nwala, A. C. A survey of 5 boilerplate removal methods., 2017.
  • (33) Pernice, K. Carousel Usability: Designing an Effective UI for Websites with Content Overload., 2013.
  • (34) Pomikalek, J. Removing Boilerplate and Duplicate Content from Web Corpora. PhD thesis, Masaryk University, Brno, Czechia, 2011.
  • (35) SalahEldeen, H. M., and Nelson, M. L.

    Carbon dating the web: Estimating the age of web resources.

    In Proceedings of the 22nd International Conference on World Wide Web (New York, NY, USA, 2013), WWW ’13 Companion, Association for Computing Machinery, p. 1075–1082.
  • (36) Schlachter, C. Personal Communication, June 2017.
  • (37) Snell, J. RFC 7240 - Prefer Header for HTTP., 2014.
  • (38) Steinberger, J., and Ježek, K. Using latent semantic analysis in text summarization and summary evaluation. In Proceedings of the 2004 International Conference on Information System Implementation and Modeling (2004).
  • (39) van Cranenburgh, A. andreasvc/readabilty - measure the readability of a given text using surface characteristics., 2019.
  • (40) Van de Sompel, H., Nelson, M., Balakireva, L., Klein, M., Jones, S., and Shankar, H. Mementos in the Raw, Take Two., 2016.
  • (41) Van de Sompel, H., Nelson, M., and Sanderson, R. RFC 7089 - HTTP Framework for Time-Based Access to Resource States – Memento., December 2013.
  • (42) Van de Sompel, H., Nelson, M. L., Balakireva, L., Jones, S. M., and Shankar, H. Proposals for uniform access to raw mementos., 2017.
  • (43) Vanderwende, L., Suzuki, H., Brockett, C., and Nenkova, A. Beyond SumBasic: Task-focused summarization with sentence simplification and lexical expansion. Information Processing & Management 43, 6 (2007), 1606–1618.
  • (44) Victor, D. Pepsi Pulls Ad Accused of Trivializing Black Lives Matter. The New York Times (2017).
  • (45) Viégas, F. B., and Wattenberg, M. Timelines tag clouds and the case for vernacular visualization. Interactions 15, 4 (2008), 49–52.
  • (46) Williams, S. 40 Social Media Curation Sites and Tools., January 2012.
  • (47) Zickelbrach, S. Personal Communication, June 2017.

Appendix A: MementoEmbed Detail Tables

API Endpoint Field Field Description
/services/memento/contentdata/ title The title discovered in the memento
snippet The snippet discovered or generated from the memento
/services/memento/bestimage/ best-image-uri The striking image discovered in or generated from the memento
/services/memento/imagedata/ images a JSON object containing each image URI-M and its calculated attributes (e.g., pixel size)
ranked images a JSON object listing each image URI-M in descending order by score
/services/memento/archivedata/ archive-uri The URI of the archive’s home page
archive-name The upper case domain name of the archive
archive-favicon The detected favicon URI for the archvie
The Collection ID for the URI-M;
only for Archive-It mementos
The Collection Name for the URI-M;
only for Archive-It mementos
The URI of the collection;
only for Archive-It mementos
/services/memento/originalresourcedata/ original-uri The URI-R of the memento
original-domain The domain of the URI-R
original-favicon The favicon discovered for this memento
original-linkstatus Is “Live” if the URI-R still responds with an HTTP 200 status code
/services/memento/seeddata/ timemap The URI-T of the memento
original-url The URI-R of the memento
memento-count The number of mementos in this memento’s TimeMap
first-memento-datetime The memento-datetime of the first memento in the TimeMap
first-urim The first URI-M in this memento’s TimeMap
last-memento-datetime The memento-datetime of the last memento in the TimeMap
last-urim The last URI-M in this memento’s TimeMap
Metadata associated with the URI-R of this
memento, if it was a seed;
only available for Archive-It collections
/services/memento/paragraphrank/ algorithm The algorithm used to score the memento’s paragraphs
scored paragraphs Each paragraph extracted from the memento and its score
/services/memento/sentencerank/ paragraph scoring algorithm The algorithm used to score the memento’s paragraphs
sentence ranking algorithm The algorithm used to score the memento’s sentences within each paragraph
/services/memento/page-metadata/ page-metadata A JSON object containing the values extracted from the memento’s META elements
Table 2: The fields provided by a successful response for the API endpoints under /services/memento/.
API Endpoint Preference Name Preference Description Possible Values Default Value
/services/memento/sentencerank/ algorithm The paragraph and sentence scoring algorithms to use readability/lede3, readability/textrank, justext/textrank readability/lede3
/services/product/socialcard/ datauri_favicon ’yes’ instructs MementoEmbed to generate data URIs for favicons yes, no no
datauri_image ’yes’ instructs MementoEmbed to generate data URIs for striking images yes, no no
using_remote_javascript ’no’ instructs MementoEmbed to construct HTML that relies on no external JavaScript yes, no yes
minify_markup ’yes’ instructs MementoEmbed to minify the output yes, no no
/services/product/thumbnail/ viewport_width the width of the viewport in pixels for the browser capturing the screenshot <= 5120 1024 px
viewport_height the height of the viewport in pixels for the browser capturing the screenshot <= 2880 768 px
thumbnail_width the width of the thumbnail in pixels for the browser capturing the screenshot <= 5120 208 px
thumbnail_height the height of the thumbnail in pixels for the browser capturing the screenshot <= 2880 156 px
timeout how long MementoEmbed should wait for Puppeteer to create a thumbnail <= 300 300 seconds
remove_banner ’yes’ instructs MementoEmbed to try to remove the archive-specific banner from the memento prior to taking the screenshot yes, no no
/services/product/imagereel/ duration the length, in seconds, between image transitions, including fades <= 300 100 seconds
imagecount the maximum number of images to include <= 10 5
width the width of the imagereel in pixels <= 5120 320 px
height the height of the imagereel in pixels <= 2880 240 px
/services/product/wordcloud/ colormap the matplotlib colormap of the Word Cloud See matplotlib_colormaps for a list of values inferno
background_color the background color of the word cloud hexadecimal values, RGB, HSL, HSV, common HTML color names white
textonly ’yes’ instructs MementoEmbed to return a JSON list of words instead of a word cloud yes, no no
/services/product/docreel/ duration the duration between transitions, including fades <= 300 100
imagecount the number of images to include <= 10 5
sentencecount the number of sentences to include <= 10 5
width the width of the docreel in pixels <= 5120 320 px
height the height of the docreel in pixels <= 2880 240 px
Table 3: The preferences available for various MementoEmbed API endpoints.

Appendix B: Raintale Detail Tables

Raintale template variable Description
element.surrogate.archive_collection_id the ID of the collection containing this URI-M
only works with URI-Ms from public Archive-It collections
element.surrogate.archive_collection_name the name of the collection containing this URI-M
only works with URI-Ms from public Archive-It collections
element.surrogate.archive_collection_uri the URI of the collection containing this URI-M
only works with URI-Ms from public Archive-It collections
element.surrogate.archive_favicon the URI of the favicon of the archive containing this URI-M
element.surrogate.archive_name the uppercase name of the domain name of the archive containing this URI-M
element.surrogate.archive_uri the URI of the archive containing this URI-M
element.surrogate.best_image_uri the URI of the best image found in the memento using the MementoEmbed image scoring equation; will be removed in the future in favor of
element.surrogate.image|prefer rank=1
element.surrogate.first_memento_datetime the datetime of the earliest memento for this resource at the web archive containing this URI-M
element.surrogate.first_urim the URI-M of the earliest memento for this resource at the web archive containing this URI-M
element.surrogate.image provides the ith best image found in the memento using the MementoEmbed image scoring equation;this allows a user to include multiple images from a memento in a surrogate
element.surrogate.imagereel provides an imagreel for the memento, as generated by MementoEmbed
element.surrogate.last_memento_datetime the datetime of the latest memento for this resource at the web archive containing this URI-M
element.surrogate.last_urim the URI-M of the latest memento for this resource at the web archive containing this URI-M
element.surrogate.memento_count the number of other mementos for this same resource at the web archive containing this URI-M
element.surrogate.memento_datetime the memento-datetime of the memento
element.surrogate.memento_datetime_14num provides the memento-datetime in YYYYMMDDHHMMSS format, a special datetime format for use in some web archive URI-Ms and API calls; will be removed in the future in favor of
element.surrogate.metadata the metadata provided for the seed of this URI-M; provides a JSON object of keys and values corresponding to the metadata fields present at the archive - only works with URI-Ms from public Archive-It collections
element.surrogate.original_domain the domain of the original resource for this URI-M
element.surrogate.original_favicon the favicon corresponding to the original resource for this URI-M
element.surrogate.original_linkstatus the status of the link at the time the story was generated
element.surrogate.original_uri the URI of the original resource (URI-R) corresponding to this memento
element.surrogate.sentence the ith best sentence found in the memento using the MementoEmbed sentence scoring equation; this allows a user to include multiple sentences from a memento in a surrogate
element.surrogate.snippet the best text extracted from the memento via MementoEmbed
element.thumbnail provides a thumbnail generated by MementoEmbed for the given URI-M as a data URI
element.surrogate.timegate_uri the URI of the Memento TimeGate (URI-G) corresponding to the resource
element.surrogate.timemap_uri the URI of the Memento TimeMap (URI-T) corresponding to the resource
element.surrogate.title the text of the title extracted from the HTML of the memento
element.surrogate.urim the URI-M of this memento
Table 4: Raintale variables available for individual mementos in a template
Raintale template variable Corresponding MementoEmbed API Endpoint
element.surrogate.archive_collection_id /services/memento/archivedata/
element.surrogate.archive_collection_name /services/memento/archivedata/
element.surrogate.archive_collection_uri /services/memento/archivedata/
element.surrogate.archive_favicon /services/memento/archivedata/
element.surrogate.archive_name /services/memento/archivedata/
element.surrogate.archive_uri /services/memento/archivedata/
element.surrogate.best_image_uri /services/memento/bestimage/
element.surrogate.first_memento_datetime /services/memento/seeddata/
element.surrogate.first_urim /services/memento/seeddata/
element.surrogate.image /services/memento/imagedata/
element.surrogate.imagereel /services/product/imagereel/
element.surrogate.last_memento_datetime /services/memento/seeddata/
element.surrogate.last_urim /services/memento/seeddata/
element.surrogate.memento_count /services/memento/seeddata/
element.surrogate.memento_datetime /services/memento/contentdata/
element.surrogate.memento_datetime_14num Calculated by Raintale based on /services/memento/contentdata/
element.surrogate.metadata /services/memento/seeddata/
element.surrogate.original_domain /services/memento/originalresourcedata/
element.surrogate.original_favicon /services/memento/originalresourcedata/
element.surrogate.original_linkstatus /services/memento/originalresourcedata/
element.surrogate.original_uri /services/memento/originalresourcedata/
element.surrogate.sentence /services/memento/sentencerank/
element.surrogate.snippet /services/memento/contentdata/
element.thumbnail /services/product/thumbnail/
element.surrogate.timegate_uri /services/memento/seeddata/
element.surrogate.timemap_uri /services/memento/seeddata/
element.surrogate.title /services/memento/contentdata/
element.surrogate.urim N/A - based on input from story file