Merge branch 'develop' into stable

46 files changed, 1587 insertions, 249 deletions

diff --git a/src/SMAPI.Web/Framework/AllowLargePostsAttribute.cs b/src/SMAPI.Web/Framework/AllowLargePostsAttribute.cs
index 5dc0feb6..864aa215 100644
--- a/src/SMAPI.Web/Framework/AllowLargePostsAttribute.cs
+++ b/src/SMAPI.Web/Framework/AllowLargePostsAttribute.cs
@@ -36,7 +36,7 @@ namespace StardewModdingAPI.Web.Framework
         }
 
         /// <summary>Called early in the filter pipeline to confirm request is authorized.</summary>
-        /// <param name="context">The authorisation filter context.</param>
+        /// <param name="context">The authorization filter context.</param>
         public void OnAuthorization(AuthorizationFilterContext context)
         {
             IFeatureCollection features = context.HttpContext.Features;
diff --git a/src/SMAPI.Web/Framework/Caching/BaseCacheRepository.cs b/src/SMAPI.Web/Framework/Caching/BaseCacheRepository.cs
new file mode 100644
index 00000000..f5354b93
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Caching/BaseCacheRepository.cs
@@ -0,0 +1,19 @@
+using System;
+
+namespace StardewModdingAPI.Web.Framework.Caching
+{
+    /// <summary>The base logic for a cache repository.</summary>
+    internal abstract class BaseCacheRepository
+    {
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Whether cached data is stale.</summary>
+        /// <param name="lastUpdated">The date when the data was updated.</param>
+        /// <param name="staleMinutes">The age in minutes before data is considered stale.</param>
+        public bool IsStale(DateTimeOffset lastUpdated, int staleMinutes)
+        {
+            return lastUpdated < DateTimeOffset.UtcNow.AddMinutes(-staleMinutes);
+        }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Caching/ICacheRepository.cs b/src/SMAPI.Web/Framework/Caching/ICacheRepository.cs
new file mode 100644
index 00000000..5de7e731
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Caching/ICacheRepository.cs
@@ -0,0 +1,13 @@
+using System;
+
+namespace StardewModdingAPI.Web.Framework.Caching
+{
+    /// <summary>Encapsulates logic for accessing data in the cache.</summary>
+    internal interface ICacheRepository
+    {
+        /// <summary>Whether cached data is stale.</summary>
+        /// <param name="lastUpdated">The date when the data was updated.</param>
+        /// <param name="staleMinutes">The age in minutes before data is considered stale.</param>
+        bool IsStale(DateTimeOffset lastUpdated, int staleMinutes);
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Caching/Mods/CachedMod.cs b/src/SMAPI.Web/Framework/Caching/Mods/CachedMod.cs
new file mode 100644
index 00000000..96eca847
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Caching/Mods/CachedMod.cs
@@ -0,0 +1,107 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization.Attributes;
+using StardewModdingAPI.Toolkit.Framework.UpdateData;
+using StardewModdingAPI.Web.Framework.ModRepositories;
+
+namespace StardewModdingAPI.Web.Framework.Caching.Mods
+{
+    /// <summary>The model for cached mod data.</summary>
+    internal class CachedMod
+    {
+        /*********
+        ** Accessors
+        *********/
+        /****
+        ** Tracking
+        ****/
+        /// <summary>The internal MongoDB ID.</summary>
+        [SuppressMessage("ReSharper", "InconsistentNaming", Justification = "Named per MongoDB conventions.")]
+        [BsonIgnoreIfDefault]
+        public ObjectId _id { get; set; }
+
+        /// <summary>When the data was last updated.</summary>
+        public DateTimeOffset LastUpdated { get; set; }
+
+        /// <summary>When the data was last requested through the web API.</summary>
+        public DateTimeOffset LastRequested { get; set; }
+
+        /****
+        ** Metadata
+        ****/
+        /// <summary>The mod site on which the mod is found.</summary>
+        public ModRepositoryKey Site { get; set; }
+
+        /// <summary>The mod's unique ID within the <see cref="Site"/>.</summary>
+        public string ID { get; set; }
+
+        /// <summary>The mod availability status on the remote site.</summary>
+        public RemoteModStatus FetchStatus { get; set; }
+
+        /// <summary>The error message providing more info for the <see cref="FetchStatus"/>, if applicable.</summary>
+        public string FetchError { get; set; }
+
+
+        /****
+        ** Mod info
+        ****/
+        /// <summary>The mod's display name.</summary>
+        public string Name { get; set; }
+
+        /// <summary>The mod's latest version.</summary>
+        public string MainVersion { get; set; }
+
+        /// <summary>The mod's latest optional or prerelease version, if newer than <see cref="MainVersion"/>.</summary>
+        public string PreviewVersion { get; set; }
+
+        /// <summary>The URL for the mod page.</summary>
+        public string Url { get; set; }
+
+        /// <summary>The license URL, if available.</summary>
+        public string LicenseUrl { get; set; }
+
+        /// <summary>The license name, if available.</summary>
+        public string LicenseName { get; set; }
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>Construct an instance.</summary>
+        public CachedMod() { }
+
+        /// <summary>Construct an instance.</summary>
+        /// <param name="site">The mod site on which the mod is found.</param>
+        /// <param name="id">The mod's unique ID within the <paramref name="site"/>.</param>
+        /// <param name="mod">The mod data.</param>
+        public CachedMod(ModRepositoryKey site, string id, ModInfoModel mod)
+        {
+            // tracking
+            this.LastUpdated = DateTimeOffset.UtcNow;
+            this.LastRequested = DateTimeOffset.UtcNow;
+
+            // metadata
+            this.Site = site;
+            this.ID = id;
+            this.FetchStatus = mod.Status;
+            this.FetchError = mod.Error;
+
+            // mod info
+            this.Name = mod.Name;
+            this.MainVersion = mod.Version;
+            this.PreviewVersion = mod.PreviewVersion;
+            this.Url = mod.Url;
+            this.LicenseUrl = mod.LicenseUrl;
+            this.LicenseName = mod.LicenseName;
+        }
+
+        /// <summary>Get the API model for the cached data.</summary>
+        public ModInfoModel GetModel()
+        {
+            return new ModInfoModel(name: this.Name, version: this.MainVersion, url: this.Url, previewVersion: this.PreviewVersion)
+                .SetLicense(this.LicenseUrl, this.LicenseName)
+                .SetError(this.FetchStatus, this.FetchError);
+        }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Caching/Mods/IModCacheRepository.cs b/src/SMAPI.Web/Framework/Caching/Mods/IModCacheRepository.cs
new file mode 100644
index 00000000..bcec8b36
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Caching/Mods/IModCacheRepository.cs
@@ -0,0 +1,31 @@
+using System;
+using StardewModdingAPI.Toolkit.Framework.UpdateData;
+using StardewModdingAPI.Web.Framework.ModRepositories;
+
+namespace StardewModdingAPI.Web.Framework.Caching.Mods
+{
+    /// <summary>Encapsulates logic for accessing the mod data cache.</summary>
+    internal interface IModCacheRepository : ICacheRepository
+    {
+        /*********
+        ** Methods
+        *********/
+        /// <summary>Get the cached mod data.</summary>
+        /// <param name="site">The mod site to search.</param>
+        /// <param name="id">The mod's unique ID within the <paramref name="site"/>.</param>
+        /// <param name="mod">The fetched mod.</param>
+        /// <param name="markRequested">Whether to update the mod's 'last requested' date.</param>
+        bool TryGetMod(ModRepositoryKey site, string id, out CachedMod mod, bool markRequested = true);
+
+        /// <summary>Save data fetched for a mod.</summary>
+        /// <param name="site">The mod site on which the mod is found.</param>
+        /// <param name="id">The mod's unique ID within the <paramref name="site"/>.</param>
+        /// <param name="mod">The mod data.</param>
+        /// <param name="cachedMod">The stored mod record.</param>
+        void SaveMod(ModRepositoryKey site, string id, ModInfoModel mod, out CachedMod cachedMod);
+
+        /// <summary>Delete data for mods which haven't been requested within a given time limit.</summary>
+        /// <param name="age">The minimum age for which to remove mods.</param>
+        void RemoveStaleMods(TimeSpan age);
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Caching/Mods/ModCacheRepository.cs b/src/SMAPI.Web/Framework/Caching/Mods/ModCacheRepository.cs
new file mode 100644
index 00000000..2e7804a7
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Caching/Mods/ModCacheRepository.cs
@@ -0,0 +1,104 @@
+using System;
+using MongoDB.Driver;
+using StardewModdingAPI.Toolkit.Framework.UpdateData;
+using StardewModdingAPI.Web.Framework.ModRepositories;
+
+namespace StardewModdingAPI.Web.Framework.Caching.Mods
+{
+    /// <summary>Encapsulates logic for accessing the mod data cache.</summary>
+    internal class ModCacheRepository : BaseCacheRepository, IModCacheRepository
+    {
+        /*********
+        ** Fields
+        *********/
+        /// <summary>The collection for cached mod data.</summary>
+        private readonly IMongoCollection<CachedMod> Mods;
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="database">The authenticated MongoDB database.</param>
+        public ModCacheRepository(IMongoDatabase database)
+        {
+            // get collections
+            this.Mods = database.GetCollection<CachedMod>("mods");
+
+            // add indexes if needed
+            this.Mods.Indexes.CreateOne(new CreateIndexModel<CachedMod>(Builders<CachedMod>.IndexKeys.Ascending(p => p.ID).Ascending(p => p.Site)));
+        }
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Get the cached mod data.</summary>
+        /// <param name="site">The mod site to search.</param>
+        /// <param name="id">The mod's unique ID within the <paramref name="site"/>.</param>
+        /// <param name="mod">The fetched mod.</param>
+        /// <param name="markRequested">Whether to update the mod's 'last requested' date.</param>
+        public bool TryGetMod(ModRepositoryKey site, string id, out CachedMod mod, bool markRequested = true)
+        {
+            // get mod
+            id = this.NormalizeId(id);
+            mod = this.Mods.Find(entry => entry.ID == id && entry.Site == site).FirstOrDefault();
+            if (mod == null)
+                return false;
+
+            // bump 'last requested'
+            if (markRequested)
+            {
+                mod.LastRequested = DateTimeOffset.UtcNow;
+                mod = this.SaveMod(mod);
+            }
+
+            return true;
+        }
+
+        /// <summary>Save data fetched for a mod.</summary>
+        /// <param name="site">The mod site on which the mod is found.</param>
+        /// <param name="id">The mod's unique ID within the <paramref name="site"/>.</param>
+        /// <param name="mod">The mod data.</param>
+        /// <param name="cachedMod">The stored mod record.</param>
+        public void SaveMod(ModRepositoryKey site, string id, ModInfoModel mod, out CachedMod cachedMod)
+        {
+            id = this.NormalizeId(id);
+
+            cachedMod = this.SaveMod(new CachedMod(site, id, mod));
+        }
+
+        /// <summary>Delete data for mods which haven't been requested within a given time limit.</summary>
+        /// <param name="age">The minimum age for which to remove mods.</param>
+        public void RemoveStaleMods(TimeSpan age)
+        {
+            DateTimeOffset minDate = DateTimeOffset.UtcNow.Subtract(age);
+            var result = this.Mods.DeleteMany(p => p.LastRequested < minDate);
+        }
+
+
+        /*********
+        ** Private methods
+        *********/
+        /// <summary>Save data fetched for a mod.</summary>
+        /// <param name="mod">The mod data.</param>
+        public CachedMod SaveMod(CachedMod mod)
+        {
+            string id = this.NormalizeId(mod.ID);
+
+            this.Mods.ReplaceOne(
+                entry => entry.ID == id && entry.Site == mod.Site,
+                mod,
+                new UpdateOptions { IsUpsert = true }
+            );
+
+            return mod;
+        }
+
+        /// <summary>Normalize a mod ID for case-insensitive search.</summary>
+        /// <param name="id">The mod ID.</param>
+        public string NormalizeId(string id)
+        {
+            return id.Trim().ToLower();
+        }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Caching/UtcDateTimeOffsetSerializer.cs b/src/SMAPI.Web/Framework/Caching/UtcDateTimeOffsetSerializer.cs
new file mode 100644
index 00000000..6a103e37
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Caching/UtcDateTimeOffsetSerializer.cs
@@ -0,0 +1,40 @@
+using System;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
+
+namespace StardewModdingAPI.Web.Framework.Caching
+{
+    /// <summary>Serializes <see cref="DateTimeOffset"/> to a UTC date field instead of the default array.</summary>
+    public class UtcDateTimeOffsetSerializer : StructSerializerBase<DateTimeOffset>
+    {
+        /*********
+        ** Fields
+        *********/
+        /// <summary>The underlying date serializer.</summary>
+        private static readonly DateTimeSerializer DateTimeSerializer = new DateTimeSerializer(DateTimeKind.Utc, BsonType.DateTime);
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Deserializes a value.</summary>
+        /// <param name="context">The deserialization context.</param>
+        /// <param name="args">The deserialization args.</param>
+        /// <returns>A deserialized value.</returns>
+        public override DateTimeOffset Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
+        {
+            DateTime date = UtcDateTimeOffsetSerializer.DateTimeSerializer.Deserialize(context, args);
+            return new DateTimeOffset(date, TimeSpan.Zero);
+        }
+
+        /// <summary>Serializes a value.</summary>
+        /// <param name="context">The serialization context.</param>
+        /// <param name="args">The serialization args.</param>
+        /// <param name="value">The object.</param>
+        public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, DateTimeOffset value)
+        {
+            UtcDateTimeOffsetSerializer.DateTimeSerializer.Serialize(context, args, value.UtcDateTime);
+        }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Caching/Wiki/CachedWikiMetadata.cs b/src/SMAPI.Web/Framework/Caching/Wiki/CachedWikiMetadata.cs
new file mode 100644
index 00000000..6a560eb4
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Caching/Wiki/CachedWikiMetadata.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using MongoDB.Bson;
+
+namespace StardewModdingAPI.Web.Framework.Caching.Wiki
+{
+    /// <summary>The model for cached wiki metadata.</summary>
+    internal class CachedWikiMetadata
+    {
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>The internal MongoDB ID.</summary>
+        [SuppressMessage("ReSharper", "InconsistentNaming", Justification = "Named per MongoDB conventions.")]
+        public ObjectId _id { get; set; }
+
+        /// <summary>When the data was last updated.</summary>
+        public DateTimeOffset LastUpdated { get; set; }
+
+        /// <summary>The current stable Stardew Valley version.</summary>
+        public string StableVersion { get; set; }
+
+        /// <summary>The current beta Stardew Valley version.</summary>
+        public string BetaVersion { get; set; }
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        public CachedWikiMetadata() { }
+
+        /// <summary>Construct an instance.</summary>
+        /// <param name="stableVersion">The current stable Stardew Valley version.</param>
+        /// <param name="betaVersion">The current beta Stardew Valley version.</param>
+        public CachedWikiMetadata(string stableVersion, string betaVersion)
+        {
+            this.StableVersion = stableVersion;
+            this.BetaVersion = betaVersion;
+            this.LastUpdated = DateTimeOffset.UtcNow;
+        }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Caching/Wiki/CachedWikiMod.cs b/src/SMAPI.Web/Framework/Caching/Wiki/CachedWikiMod.cs
new file mode 100644
index 00000000..8569984a
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Caching/Wiki/CachedWikiMod.cs
@@ -0,0 +1,230 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Bson.Serialization.Options;
+using StardewModdingAPI.Toolkit;
+using StardewModdingAPI.Toolkit.Framework.Clients.Wiki;
+
+namespace StardewModdingAPI.Web.Framework.Caching.Wiki
+{
+    /// <summary>The model for cached wiki mods.</summary>
+    internal class CachedWikiMod
+    {
+        /*********
+        ** Accessors
+        *********/
+        /****
+        ** Tracking
+        ****/
+        /// <summary>The internal MongoDB ID.</summary>
+        [SuppressMessage("ReSharper", "InconsistentNaming", Justification = "Named per MongoDB conventions.")]
+        public ObjectId _id { get; set; }
+
+        /// <summary>When the data was last updated.</summary>
+        public DateTimeOffset LastUpdated { get; set; }
+
+        /****
+        ** Mod info
+        ****/
+        /// <summary>The mod's unique ID. If the mod has alternate/old IDs, they're listed in latest to newest order.</summary>
+        public string[] ID { get; set; }
+
+        /// <summary>The mod's display name. If the mod has multiple names, the first one is the most canonical name.</summary>
+        public string[] Name { get; set; }
+
+        /// <summary>The mod's author name.  If the author has multiple names, the first one is the most canonical name.</summary>
+        public string[] Author { get; set; }
+
+        /// <summary>The mod ID on Nexus.</summary>
+        public int? NexusID { get; set; }
+
+        /// <summary>The mod ID in the Chucklefish mod repo.</summary>
+        public int? ChucklefishID { get; set; }
+
+        /// <summary>The mod ID in the CurseForge mod repo.</summary>
+        public int? CurseForgeID { get; set; }
+
+        /// <summary>The mod key in the CurseForge mod repo (used in mod page URLs).</summary>
+        public string CurseForgeKey { get; set; }
+
+        /// <summary>The mod ID in the ModDrop mod repo.</summary>
+        public int? ModDropID { get; set; }
+
+        /// <summary>The GitHub repository in the form 'owner/repo'.</summary>
+        public string GitHubRepo { get; set; }
+
+        /// <summary>The URL to a non-GitHub source repo.</summary>
+        public string CustomSourceUrl { get; set; }
+
+        /// <summary>The custom mod page URL (if applicable).</summary>
+        public string CustomUrl { get; set; }
+
+        /// <summary>The name of the mod which loads this content pack, if applicable.</summary>
+        public string ContentPackFor { get; set; }
+
+        /// <summary>The human-readable warnings for players about this mod.</summary>
+        public string[] Warnings { get; set; }
+
+        /// <summary>Extra metadata links (usually for open pull requests).</summary>
+        public Tuple<Uri, string>[] MetadataLinks { get; set; }
+
+        /// <summary>Special notes intended for developers who maintain unofficial updates or submit pull requests. </summary>
+        public string DevNote { get; set; }
+
+        /// <summary>The link anchor for the mod entry in the wiki compatibility list.</summary>
+        public string Anchor { get; set; }
+
+        /****
+        ** Stable compatibility
+        ****/
+        /// <summary>The compatibility status.</summary>
+        public WikiCompatibilityStatus MainStatus { get; set; }
+
+        /// <summary>The human-readable summary of the compatibility status or workaround, without HTML formatting.</summary>
+        public string MainSummary { get; set; }
+
+        /// <summary>The game or SMAPI version which broke this mod (if applicable).</summary>
+        public string MainBrokeIn { get; set; }
+
+        /// <summary>The version of the latest unofficial update, if applicable.</summary>
+        public string MainUnofficialVersion { get; set; }
+
+        /// <summary>The URL to the latest unofficial update, if applicable.</summary>
+        public string MainUnofficialUrl { get; set; }
+
+        /****
+        ** Beta compatibility
+        ****/
+        /// <summary>The compatibility status.</summary>
+        public WikiCompatibilityStatus? BetaStatus { get; set; }
+
+        /// <summary>The human-readable summary of the compatibility status or workaround, without HTML formatting.</summary>
+        public string BetaSummary { get; set; }
+
+        /// <summary>The game or SMAPI version which broke this mod (if applicable).</summary>
+        public string BetaBrokeIn { get; set; }
+
+        /// <summary>The version of the latest unofficial update, if applicable.</summary>
+        public string BetaUnofficialVersion { get; set; }
+
+        /// <summary>The URL to the latest unofficial update, if applicable.</summary>
+        public string BetaUnofficialUrl { get; set; }
+
+        /****
+        ** Version maps
+        ****/
+        /// <summary>Maps local versions to a semantic version for update checks.</summary>
+        [BsonDictionaryOptions(Representation = DictionaryRepresentation.ArrayOfArrays)]
+        public IDictionary<string, string> MapLocalVersions { get; set; }
+
+        /// <summary>Maps remote versions to a semantic version for update checks.</summary>
+        [BsonDictionaryOptions(Representation = DictionaryRepresentation.ArrayOfArrays)]
+        public IDictionary<string, string> MapRemoteVersions { get; set; }
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>Construct an instance.</summary>
+        public CachedWikiMod() { }
+
+        /// <summary>Construct an instance.</summary>
+        /// <param name="mod">The mod data.</param>
+        public CachedWikiMod(WikiModEntry mod)
+        {
+            // tracking
+            this.LastUpdated = DateTimeOffset.UtcNow;
+
+            // mod info
+            this.ID = mod.ID;
+            this.Name = mod.Name;
+            this.Author = mod.Author;
+            this.NexusID = mod.NexusID;
+            this.ChucklefishID = mod.ChucklefishID;
+            this.CurseForgeID = mod.CurseForgeID;
+            this.CurseForgeKey = mod.CurseForgeKey;
+            this.ModDropID = mod.ModDropID;
+            this.GitHubRepo = mod.GitHubRepo;
+            this.CustomSourceUrl = mod.CustomSourceUrl;
+            this.CustomUrl = mod.CustomUrl;
+            this.ContentPackFor = mod.ContentPackFor;
+            this.MetadataLinks = mod.MetadataLinks;
+            this.Warnings = mod.Warnings;
+            this.DevNote = mod.DevNote;
+            this.Anchor = mod.Anchor;
+
+            // stable compatibility
+            this.MainStatus = mod.Compatibility.Status;
+            this.MainSummary = mod.Compatibility.Summary;
+            this.MainBrokeIn = mod.Compatibility.BrokeIn;
+            this.MainUnofficialVersion = mod.Compatibility.UnofficialVersion?.ToString();
+            this.MainUnofficialUrl = mod.Compatibility.UnofficialUrl;
+
+            // beta compatibility
+            this.BetaStatus = mod.BetaCompatibility?.Status;
+            this.BetaSummary = mod.BetaCompatibility?.Summary;
+            this.BetaBrokeIn = mod.BetaCompatibility?.BrokeIn;
+            this.BetaUnofficialVersion = mod.BetaCompatibility?.UnofficialVersion?.ToString();
+            this.BetaUnofficialUrl = mod.BetaCompatibility?.UnofficialUrl;
+
+            // version maps
+            this.MapLocalVersions = mod.MapLocalVersions;
+            this.MapRemoteVersions = mod.MapRemoteVersions;
+        }
+
+        /// <summary>Reconstruct the original model.</summary>
+        public WikiModEntry GetModel()
+        {
+            var mod = new WikiModEntry
+            {
+                ID = this.ID,
+                Name = this.Name,
+                Author = this.Author,
+                NexusID = this.NexusID,
+                ChucklefishID = this.ChucklefishID,
+                CurseForgeID = this.CurseForgeID,
+                CurseForgeKey = this.CurseForgeKey,
+                ModDropID = this.ModDropID,
+                GitHubRepo = this.GitHubRepo,
+                CustomSourceUrl = this.CustomSourceUrl,
+                CustomUrl = this.CustomUrl,
+                ContentPackFor = this.ContentPackFor,
+                Warnings = this.Warnings,
+                MetadataLinks = this.MetadataLinks,
+                DevNote = this.DevNote,
+                Anchor = this.Anchor,
+
+                // stable compatibility
+                Compatibility = new WikiCompatibilityInfo
+                {
+                    Status = this.MainStatus,
+                    Summary = this.MainSummary,
+                    BrokeIn = this.MainBrokeIn,
+                    UnofficialVersion = this.MainUnofficialVersion != null ? new SemanticVersion(this.MainUnofficialVersion) : null,
+                    UnofficialUrl = this.MainUnofficialUrl
+                },
+
+                // version maps
+                MapLocalVersions = this.MapLocalVersions,
+                MapRemoteVersions = this.MapRemoteVersions
+            };
+
+            // beta compatibility
+            if (this.BetaStatus != null)
+            {
+                mod.BetaCompatibility = new WikiCompatibilityInfo
+                {
+                    Status = this.BetaStatus.Value,
+                    Summary = this.BetaSummary,
+                    BrokeIn = this.BetaBrokeIn,
+                    UnofficialVersion = this.BetaUnofficialVersion != null ? new SemanticVersion(this.BetaUnofficialVersion) : null,
+                    UnofficialUrl = this.BetaUnofficialUrl
+                };
+            }
+
+            return mod;
+        }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Caching/Wiki/IWikiCacheRepository.cs b/src/SMAPI.Web/Framework/Caching/Wiki/IWikiCacheRepository.cs
new file mode 100644
index 00000000..b54c8a2f
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Caching/Wiki/IWikiCacheRepository.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using StardewModdingAPI.Toolkit.Framework.Clients.Wiki;
+
+namespace StardewModdingAPI.Web.Framework.Caching.Wiki
+{
+    /// <summary>Encapsulates logic for accessing the wiki data cache.</summary>
+    internal interface IWikiCacheRepository : ICacheRepository
+    {
+        /*********
+        ** Methods
+        *********/
+        /// <summary>Get the cached wiki metadata.</summary>
+        /// <param name="metadata">The fetched metadata.</param>
+        bool TryGetWikiMetadata(out CachedWikiMetadata metadata);
+
+        /// <summary>Get the cached wiki mods.</summary>
+        /// <param name="filter">A filter to apply, if any.</param>
+        IEnumerable<CachedWikiMod> GetWikiMods(Expression<Func<CachedWikiMod, bool>> filter = null);
+
+        /// <summary>Save data fetched from the wiki compatibility list.</summary>
+        /// <param name="stableVersion">The current stable Stardew Valley version.</param>
+        /// <param name="betaVersion">The current beta Stardew Valley version.</param>
+        /// <param name="mods">The mod data.</param>
+        /// <param name="cachedMetadata">The stored metadata record.</param>
+        /// <param name="cachedMods">The stored mod records.</param>
+        void SaveWikiData(string stableVersion, string betaVersion, IEnumerable<WikiModEntry> mods, out CachedWikiMetadata cachedMetadata, out CachedWikiMod[] cachedMods);
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Caching/Wiki/WikiCacheRepository.cs b/src/SMAPI.Web/Framework/Caching/Wiki/WikiCacheRepository.cs
new file mode 100644
index 00000000..1ae9d38f
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Caching/Wiki/WikiCacheRepository.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using MongoDB.Driver;
+using StardewModdingAPI.Toolkit.Framework.Clients.Wiki;
+
+namespace StardewModdingAPI.Web.Framework.Caching.Wiki
+{
+    /// <summary>Encapsulates logic for accessing the wiki data cache.</summary>
+    internal class WikiCacheRepository : BaseCacheRepository, IWikiCacheRepository
+    {
+        /*********
+        ** Fields
+        *********/
+        /// <summary>The collection for wiki metadata.</summary>
+        private readonly IMongoCollection<CachedWikiMetadata> WikiMetadata;
+
+        /// <summary>The collection for wiki mod data.</summary>
+        private readonly IMongoCollection<CachedWikiMod> WikiMods;
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="database">The authenticated MongoDB database.</param>
+        public WikiCacheRepository(IMongoDatabase database)
+        {
+            // get collections
+            this.WikiMetadata = database.GetCollection<CachedWikiMetadata>("wiki-metadata");
+            this.WikiMods = database.GetCollection<CachedWikiMod>("wiki-mods");
+
+            // add indexes if needed
+            this.WikiMods.Indexes.CreateOne(new CreateIndexModel<CachedWikiMod>(Builders<CachedWikiMod>.IndexKeys.Ascending(p => p.ID)));
+        }
+
+        /// <summary>Get the cached wiki metadata.</summary>
+        /// <param name="metadata">The fetched metadata.</param>
+        public bool TryGetWikiMetadata(out CachedWikiMetadata metadata)
+        {
+            metadata = this.WikiMetadata.Find("{}").FirstOrDefault();
+            return metadata != null;
+        }
+
+        /// <summary>Get the cached wiki mods.</summary>
+        /// <param name="filter">A filter to apply, if any.</param>
+        public IEnumerable<CachedWikiMod> GetWikiMods(Expression<Func<CachedWikiMod, bool>> filter = null)
+        {
+            return filter != null
+                ? this.WikiMods.Find(filter).ToList()
+                : this.WikiMods.Find("{}").ToList();
+        }
+
+        /// <summary>Save data fetched from the wiki compatibility list.</summary>
+        /// <param name="stableVersion">The current stable Stardew Valley version.</param>
+        /// <param name="betaVersion">The current beta Stardew Valley version.</param>
+        /// <param name="mods">The mod data.</param>
+        /// <param name="cachedMetadata">The stored metadata record.</param>
+        /// <param name="cachedMods">The stored mod records.</param>
+        public void SaveWikiData(string stableVersion, string betaVersion, IEnumerable<WikiModEntry> mods, out CachedWikiMetadata cachedMetadata, out CachedWikiMod[] cachedMods)
+        {
+            cachedMetadata = new CachedWikiMetadata(stableVersion, betaVersion);
+            cachedMods = mods.Select(mod => new CachedWikiMod(mod)).ToArray();
+
+            this.WikiMods.DeleteMany("{}");
+            this.WikiMods.InsertMany(cachedMods);
+
+            this.WikiMetadata.DeleteMany("{}");
+            this.WikiMetadata.InsertOne(cachedMetadata);
+        }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Clients/Chucklefish/ChucklefishClient.cs b/src/SMAPI.Web/Framework/Clients/Chucklefish/ChucklefishClient.cs
index 2753e33a..939c32c6 100644
--- a/src/SMAPI.Web/Framework/Clients/Chucklefish/ChucklefishClient.cs
+++ b/src/SMAPI.Web/Framework/Clients/Chucklefish/ChucklefishClient.cs
@@ -45,7 +45,7 @@ namespace StardewModdingAPI.Web.Framework.Clients.Chucklefish
                     .GetAsync(string.Format(this.ModPageUrlFormat, id))
                     .AsString();
             }
-            catch (ApiException ex) when (ex.Status == HttpStatusCode.NotFound)
+            catch (ApiException ex) when (ex.Status == HttpStatusCode.NotFound || ex.Status == HttpStatusCode.Forbidden)
             {
                 return null;
             }
diff --git a/src/SMAPI.Web/Framework/Clients/CurseForge/CurseForgeClient.cs b/src/SMAPI.Web/Framework/Clients/CurseForge/CurseForgeClient.cs
new file mode 100644
index 00000000..140b854e
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Clients/CurseForge/CurseForgeClient.cs
@@ -0,0 +1,113 @@
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using Pathoschild.Http.Client;
+using StardewModdingAPI.Toolkit;
+using StardewModdingAPI.Web.Framework.Clients.CurseForge.ResponseModels;
+
+namespace StardewModdingAPI.Web.Framework.Clients.CurseForge
+{
+    /// <summary>An HTTP client for fetching mod metadata from the CurseForge API.</summary>
+    internal class CurseForgeClient : ICurseForgeClient
+    {
+        /*********
+        ** Fields
+        *********/
+        /// <summary>The underlying HTTP client.</summary>
+        private readonly IClient Client;
+
+        /// <summary>A regex pattern which matches a version number in a CurseForge mod file name.</summary>
+        private readonly Regex VersionInNamePattern = new Regex(@"^(?:.+? | *)v?(\d+\.\d+(?:\.\d+)?(?:-.+?)?) *(?:\.(?:zip|rar|7z))?$", RegexOptions.Compiled);
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="userAgent">The user agent for the API client.</param>
+        /// <param name="apiUrl">The base URL for the CurseForge API.</param>
+        public CurseForgeClient(string userAgent, string apiUrl)
+        {
+            this.Client = new FluentClient(apiUrl).SetUserAgent(userAgent);
+        }
+
+        /// <summary>Get metadata about a mod.</summary>
+        /// <param name="id">The CurseForge mod ID.</param>
+        /// <returns>Returns the mod info if found, else <c>null</c>.</returns>
+        public async Task<CurseForgeMod> GetModAsync(long id)
+        {
+            // get raw data
+            ModModel mod = await this.Client
+                .GetAsync($"addon/{id}")
+                .As<ModModel>();
+            if (mod == null)
+                return null;
+
+            // get latest versions
+            string invalidVersion = null;
+            ISemanticVersion latest = null;
+            foreach (ModFileModel file in mod.LatestFiles)
+            {
+                // extract version
+                ISemanticVersion version;
+                {
+                    string raw = this.GetRawVersion(file);
+                    if (raw == null)
+                        continue;
+
+                    if (!SemanticVersion.TryParse(raw, out version))
+                    {
+                        if (invalidVersion == null)
+                            invalidVersion = raw;
+                        continue;
+                    }
+                }
+
+                // track latest version
+                if (latest == null || version.IsNewerThan(latest))
+                    latest = version;
+            }
+
+            // get error
+            string error = null;
+            if (latest == null && invalidVersion == null)
+            {
+                error = mod.LatestFiles.Any()
+                    ? $"CurseForge mod {id} has no downloads which specify the version in a recognised format."
+                    : $"CurseForge mod {id} has no downloads.";
+            }
+
+            // generate result
+            return new CurseForgeMod
+            {
+                Name = mod.Name,
+                LatestVersion = latest?.ToString() ?? invalidVersion,
+                Url = mod.WebsiteUrl,
+                Error = error
+            };
+        }
+
+        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
+        public void Dispose()
+        {
+            this.Client?.Dispose();
+        }
+
+
+        /*********
+        ** Private methods
+        *********/
+        /// <summary>Get a raw version string for a mod file, if available.</summary>
+        /// <param name="file">The file whose version to get.</param>
+        private string GetRawVersion(ModFileModel file)
+        {
+            Match match = this.VersionInNamePattern.Match(file.DisplayName);
+            if (!match.Success)
+                match = this.VersionInNamePattern.Match(file.FileName);
+
+            return match.Success
+                ? match.Groups[1].Value
+                : null;
+        }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Clients/CurseForge/CurseForgeMod.cs b/src/SMAPI.Web/Framework/Clients/CurseForge/CurseForgeMod.cs
new file mode 100644
index 00000000..e5bb8cf1
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Clients/CurseForge/CurseForgeMod.cs
@@ -0,0 +1,23 @@
+using Newtonsoft.Json;
+
+namespace StardewModdingAPI.Web.Framework.Clients.CurseForge
+{
+    /// <summary>Mod metadata from the CurseForge API.</summary>
+    internal class CurseForgeMod
+    {
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>The mod name.</summary>
+        public string Name { get; set; }
+
+        /// <summary>The latest file version.</summary>
+        public string LatestVersion { get; set; }
+
+        /// <summary>The mod's web URL.</summary>
+        public string Url { get; set; }
+
+        /// <summary>A user-friendly error which indicates why fetching the mod info failed (if applicable).</summary>
+        public string Error { get; set; }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Clients/CurseForge/ICurseForgeClient.cs b/src/SMAPI.Web/Framework/Clients/CurseForge/ICurseForgeClient.cs
new file mode 100644
index 00000000..907b4087
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Clients/CurseForge/ICurseForgeClient.cs
@@ -0,0 +1,17 @@
+using System;
+using System.Threading.Tasks;
+
+namespace StardewModdingAPI.Web.Framework.Clients.CurseForge
+{
+    /// <summary>An HTTP client for fetching mod metadata from the CurseForge API.</summary>
+    internal interface ICurseForgeClient : IDisposable
+    {
+        /*********
+        ** Methods
+        *********/
+        /// <summary>Get metadata about a mod.</summary>
+        /// <param name="id">The CurseForge mod ID.</param>
+        /// <returns>Returns the mod info if found, else <c>null</c>.</returns>
+        Task<CurseForgeMod> GetModAsync(long id);
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Clients/CurseForge/ResponseModels/ModFileModel.cs b/src/SMAPI.Web/Framework/Clients/CurseForge/ResponseModels/ModFileModel.cs
new file mode 100644
index 00000000..9de74847
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Clients/CurseForge/ResponseModels/ModFileModel.cs
@@ -0,0 +1,12 @@
+namespace StardewModdingAPI.Web.Framework.Clients.CurseForge.ResponseModels
+{
+    /// <summary>Metadata from the CurseForge API about a mod file.</summary>
+    public class ModFileModel
+    {
+        /// <summary>The file name as downloaded.</summary>
+        public string FileName { get; set; }
+
+        /// <summary>The file display name.</summary>
+        public string DisplayName { get; set; }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Clients/CurseForge/ResponseModels/ModModel.cs b/src/SMAPI.Web/Framework/Clients/CurseForge/ResponseModels/ModModel.cs
new file mode 100644
index 00000000..48cd185b
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Clients/CurseForge/ResponseModels/ModModel.cs
@@ -0,0 +1,18 @@
+namespace StardewModdingAPI.Web.Framework.Clients.CurseForge.ResponseModels
+{
+    /// <summary>An mod from the CurseForge API.</summary>
+    public class ModModel
+    {
+        /// <summary>The mod's unique ID on CurseForge.</summary>
+        public int ID { get; set; }
+
+        /// <summary>The mod name.</summary>
+        public string Name { get; set; }
+
+        /// <summary>The web URL for the mod page.</summary>
+        public string WebsiteUrl { get; set; }
+
+        /// <summary>The available file downloads.</summary>
+        public ModFileModel[] LatestFiles { get; set; }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Clients/GitHub/GitHubClient.cs b/src/SMAPI.Web/Framework/Clients/GitHub/GitHubClient.cs
index 22950db9..84c20957 100644
--- a/src/SMAPI.Web/Framework/Clients/GitHub/GitHubClient.cs
+++ b/src/SMAPI.Web/Framework/Clients/GitHub/GitHubClient.cs
@@ -12,12 +12,6 @@ namespace StardewModdingAPI.Web.Framework.Clients.GitHub
         /*********
         ** Fields
         *********/
-        /// <summary>The URL for a GitHub API query for the latest stable release, excluding the base URL, where {0} is the organisation and project name.</summary>
-        private readonly string StableReleaseUrlFormat;
-
-        /// <summary>The URL for a GitHub API query for the latest release (including prerelease), excluding the base URL, where {0} is the organisation and project name.</summary>
-        private readonly string AnyReleaseUrlFormat;
-
         /// <summary>The underlying HTTP client.</summary>
         private readonly IClient Client;
 
@@ -27,17 +21,12 @@ namespace StardewModdingAPI.Web.Framework.Clients.GitHub
         *********/
         /// <summary>Construct an instance.</summary>
         /// <param name="baseUrl">The base URL for the GitHub API.</param>
-        /// <param name="stableReleaseUrlFormat">The URL for a GitHub API query for the latest stable release, excluding the <paramref name="baseUrl"/>, where {0} is the organisation and project name.</param>
-        /// <param name="anyReleaseUrlFormat">The URL for a GitHub API query for the latest release (including prerelease), excluding the <paramref name="baseUrl"/>, where {0} is the organisation and project name.</param>
         /// <param name="userAgent">The user agent for the API client.</param>
         /// <param name="acceptHeader">The Accept header value expected by the GitHub API.</param>
         /// <param name="username">The username with which to authenticate to the GitHub API.</param>
         /// <param name="password">The password with which to authenticate to the GitHub API.</param>
-        public GitHubClient(string baseUrl, string stableReleaseUrlFormat, string anyReleaseUrlFormat, string userAgent, string acceptHeader, string username, string password)
+        public GitHubClient(string baseUrl, string userAgent, string acceptHeader, string username, string password)
         {
-            this.StableReleaseUrlFormat = stableReleaseUrlFormat;
-            this.AnyReleaseUrlFormat = anyReleaseUrlFormat;
-
             this.Client = new FluentClient(baseUrl)
                 .SetUserAgent(userAgent)
                 .AddDefault(req => req.WithHeader("Accept", acceptHeader));
@@ -45,25 +34,43 @@ namespace StardewModdingAPI.Web.Framework.Clients.GitHub
                 this.Client = this.Client.SetBasicAuthentication(username, password);
         }
 
+        /// <summary>Get basic metadata for a GitHub repository, if available.</summary>
+        /// <param name="repo">The repository key (like <c>Pathoschild/SMAPI</c>).</param>
+        /// <returns>Returns the repository info if it exists, else <c>null</c>.</returns>
+        public async Task<GitRepo> GetRepositoryAsync(string repo)
+        {
+            this.AssertKeyFormat(repo);
+            try
+            {
+                return await this.Client
+                    .GetAsync($"repos/{repo}")
+                    .As<GitRepo>();
+            }
+            catch (ApiException ex) when (ex.Status == HttpStatusCode.NotFound)
+            {
+                return null;
+            }
+        }
+
         /// <summary>Get the latest release for a GitHub repository.</summary>
         /// <param name="repo">The repository key (like <c>Pathoschild/SMAPI</c>).</param>
         /// <param name="includePrerelease">Whether to return a prerelease version if it's latest.</param>
         /// <returns>Returns the release if found, else <c>null</c>.</returns>
         public async Task<GitRelease> GetLatestReleaseAsync(string repo, bool includePrerelease = false)
         {
-            this.AssetKeyFormat(repo);
+            this.AssertKeyFormat(repo);
             try
             {
                 if (includePrerelease)
                 {
                     GitRelease[] results = await this.Client
-                        .GetAsync(string.Format(this.AnyReleaseUrlFormat, repo))
+                        .GetAsync($"repos/{repo}/releases?per_page=2") // allow for draft release (only visible if GitHub repo is owned by same account as the update check credentials)
                         .AsArray<GitRelease>();
                     return results.FirstOrDefault(p => !p.IsDraft);
                 }
 
                 return await this.Client
-                    .GetAsync(string.Format(this.StableReleaseUrlFormat, repo))
+                    .GetAsync($"repos/{repo}/releases/latest")
                     .As<GitRelease>();
             }
             catch (ApiException ex) when (ex.Status == HttpStatusCode.NotFound)
@@ -85,7 +92,7 @@ namespace StardewModdingAPI.Web.Framework.Clients.GitHub
         /// <summary>Assert that a repository key is formatted correctly.</summary>
         /// <param name="repo">The repository key (like <c>Pathoschild/SMAPI</c>).</param>
         /// <exception cref="ArgumentException">The repository key is invalid.</exception>
-        private void AssetKeyFormat(string repo)
+        private void AssertKeyFormat(string repo)
         {
             if (repo == null || !repo.Contains("/") || repo.IndexOf("/", StringComparison.InvariantCultureIgnoreCase) != repo.LastIndexOf("/", StringComparison.InvariantCultureIgnoreCase))
                 throw new ArgumentException($"The value '{repo}' isn't a valid GitHub repository key, must be a username and project name like 'Pathoschild/SMAPI'.", nameof(repo));
diff --git a/src/SMAPI.Web/Framework/Clients/GitHub/GitLicense.cs b/src/SMAPI.Web/Framework/Clients/GitHub/GitLicense.cs
new file mode 100644
index 00000000..736efbe6
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Clients/GitHub/GitLicense.cs
@@ -0,0 +1,20 @@
+using Newtonsoft.Json;
+
+namespace StardewModdingAPI.Web.Framework.Clients.GitHub
+{
+    /// <summary>The license info for a GitHub project.</summary>
+    internal class GitLicense
+    {
+        /// <summary>The license display name.</summary>
+        [JsonProperty("name")]
+        public string Name { get; set; }
+
+        /// <summary>The SPDX ID for the license.</summary>
+        [JsonProperty("spdx_id")]
+        public string SpdxId { get; set; }
+
+        /// <summary>The URL for the license info.</summary>
+        [JsonProperty("url")]
+        public string Url { get; set; }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Clients/GitHub/GitRepo.cs b/src/SMAPI.Web/Framework/Clients/GitHub/GitRepo.cs
new file mode 100644
index 00000000..7d80576e
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Clients/GitHub/GitRepo.cs
@@ -0,0 +1,20 @@
+using Newtonsoft.Json;
+
+namespace StardewModdingAPI.Web.Framework.Clients.GitHub
+{
+    /// <summary>Basic metadata about a GitHub project.</summary>
+    internal class GitRepo
+    {
+        /// <summary>The full repository name, including the owner.</summary>
+        [JsonProperty("full_name")]
+        public string FullName { get; set; }
+
+        /// <summary>The URL to the repository web page, if any.</summary>
+        [JsonProperty("html_url")]
+        public string WebUrl { get; set; }
+
+        /// <summary>The code license, if any.</summary>
+        [JsonProperty("license")]
+        public GitLicense License { get; set; }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Clients/GitHub/IGitHubClient.cs b/src/SMAPI.Web/Framework/Clients/GitHub/IGitHubClient.cs
index 9519c26f..a34f03bd 100644
--- a/src/SMAPI.Web/Framework/Clients/GitHub/IGitHubClient.cs
+++ b/src/SMAPI.Web/Framework/Clients/GitHub/IGitHubClient.cs
@@ -9,6 +9,11 @@ namespace StardewModdingAPI.Web.Framework.Clients.GitHub
         /*********
         ** Methods
         *********/
+        /// <summary>Get basic metadata for a GitHub repository, if available.</summary>
+        /// <param name="repo">The repository key (like <c>Pathoschild/SMAPI</c>).</param>
+        /// <returns>Returns the repository info if it exists, else <c>null</c>.</returns>
+        Task<GitRepo> GetRepositoryAsync(string repo);
+
         /// <summary>Get the latest release for a GitHub repository.</summary>
         /// <param name="repo">The repository key (like <c>Pathoschild/SMAPI</c>).</param>
         /// <param name="includePrerelease">Whether to return a prerelease version if it's latest.</param>
diff --git a/src/SMAPI.Web/Framework/Clients/ModDrop/ModDropMod.cs b/src/SMAPI.Web/Framework/Clients/ModDrop/ModDropMod.cs
index 291fb353..def79106 100644
--- a/src/SMAPI.Web/Framework/Clients/ModDrop/ModDropMod.cs
+++ b/src/SMAPI.Web/Framework/Clients/ModDrop/ModDropMod.cs
@@ -17,8 +17,5 @@ namespace StardewModdingAPI.Web.Framework.Clients.ModDrop
 
         /// <summary>The mod's web URL.</summary>
         public string Url { get; set; }
-
-        /// <summary>A user-friendly error which indicates why fetching the mod info failed (if applicable).</summary>
-        public string Error { get; set; }
     }
 }
diff --git a/src/SMAPI.Web/Framework/Clients/Nexus/NexusClient.cs b/src/SMAPI.Web/Framework/Clients/Nexus/NexusClient.cs
new file mode 100644
index 00000000..753d3b4f
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Clients/Nexus/NexusClient.cs
@@ -0,0 +1,225 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using HtmlAgilityPack;
+using Pathoschild.FluentNexus.Models;
+using Pathoschild.Http.Client;
+using StardewModdingAPI.Toolkit;
+using FluentNexusClient = Pathoschild.FluentNexus.NexusClient;
+
+namespace StardewModdingAPI.Web.Framework.Clients.Nexus
+{
+    /// <summary>An HTTP client for fetching mod metadata from the Nexus website.</summary>
+    internal class NexusClient : INexusClient
+    {
+        /*********
+        ** Fields
+        *********/
+        /// <summary>The URL for a Nexus mod page for the user, excluding the base URL, where {0} is the mod ID.</summary>
+        private readonly string WebModUrlFormat;
+
+        /// <summary>The URL for a Nexus mod page to scrape for versions, excluding the base URL, where {0} is the mod ID.</summary>
+        public string WebModScrapeUrlFormat { get; set; }
+
+        /// <summary>The underlying HTTP client for the Nexus Mods website.</summary>
+        private readonly IClient WebClient;
+
+        /// <summary>The underlying HTTP client for the Nexus API.</summary>
+        private readonly FluentNexusClient ApiClient;
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="webUserAgent">The user agent for the Nexus Mods web client.</param>
+        /// <param name="webBaseUrl">The base URL for the Nexus Mods site.</param>
+        /// <param name="webModUrlFormat">The URL for a Nexus Mods mod page for the user, excluding the <paramref name="webBaseUrl"/>, where {0} is the mod ID.</param>
+        /// <param name="webModScrapeUrlFormat">The URL for a Nexus mod page to scrape for versions, excluding the base URL, where {0} is the mod ID.</param>
+        /// <param name="apiAppVersion">The app version to show in API user agents.</param>
+        /// <param name="apiKey">The Nexus API authentication key.</param>
+        public NexusClient(string webUserAgent, string webBaseUrl, string webModUrlFormat, string webModScrapeUrlFormat, string apiAppVersion, string apiKey)
+        {
+            this.WebModUrlFormat = webModUrlFormat;
+            this.WebModScrapeUrlFormat = webModScrapeUrlFormat;
+            this.WebClient = new FluentClient(webBaseUrl).SetUserAgent(webUserAgent);
+            this.ApiClient = new FluentNexusClient(apiKey, "SMAPI", apiAppVersion);
+        }
+
+        /// <summary>Get metadata about a mod.</summary>
+        /// <param name="id">The Nexus mod ID.</param>
+        /// <returns>Returns the mod info if found, else <c>null</c>.</returns>
+        public async Task<NexusMod> GetModAsync(uint id)
+        {
+            // Fetch from the Nexus website when possible, since it has no rate limits. Mods with
+            // adult content are hidden for anonymous users, so fall back to the API in that case.
+            // Note that the API has very restrictive rate limits which means we can't just use it
+            // for all cases.
+            NexusMod mod = await this.GetModFromWebsiteAsync(id);
+            if (mod?.Status == NexusModStatus.AdultContentForbidden)
+                mod = await this.GetModFromApiAsync(id);
+
+            return mod;
+        }
+
+        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
+        public void Dispose()
+        {
+            this.WebClient?.Dispose();
+        }
+
+
+        /*********
+        ** Private methods
+        *********/
+        /// <summary>Get metadata about a mod by scraping the Nexus website.</summary>
+        /// <param name="id">The Nexus mod ID.</param>
+        /// <returns>Returns the mod info if found, else <c>null</c>.</returns>
+        private async Task<NexusMod> GetModFromWebsiteAsync(uint id)
+        {
+            // fetch HTML
+            string html;
+            try
+            {
+                html = await this.WebClient
+                    .GetAsync(string.Format(this.WebModScrapeUrlFormat, id))
+                    .AsString();
+            }
+            catch (ApiException ex) when (ex.Status == HttpStatusCode.NotFound)
+            {
+                return null;
+            }
+
+            // parse HTML
+            var doc = new HtmlDocument();
+            doc.LoadHtml(html);
+
+            // handle Nexus error message
+            HtmlNode node = doc.DocumentNode.SelectSingleNode("//div[contains(@class, 'site-notice')][contains(@class, 'warning')]");
+            if (node != null)
+            {
+                string[] errorParts = node.InnerText.Trim().Split(new[] { '\n' }, 2, System.StringSplitOptions.RemoveEmptyEntries);
+                string errorCode = errorParts[0];
+                string errorText = errorParts.Length > 1 ? errorParts[1] : null;
+                switch (errorCode.Trim().ToLower())
+                {
+                    case "not found":
+                        return null;
+
+                    default:
+                        return new NexusMod { Error = $"Nexus error: {errorCode} ({errorText}).", Status = this.GetWebStatus(errorCode) };
+                }
+            }
+
+            // extract mod info
+            string url = this.GetModUrl(id);
+            string name = doc.DocumentNode.SelectSingleNode("//h1")?.InnerText.Trim();
+            string version = doc.DocumentNode.SelectSingleNode("//ul[contains(@class, 'stats')]//li[@class='stat-version']//div[@class='stat']")?.InnerText.Trim();
+            SemanticVersion.TryParse(version, out ISemanticVersion parsedVersion);
+
+            // extract file versions
+            List<string> rawVersions = new List<string>();
+            foreach (var fileSection in doc.DocumentNode.SelectNodes("//div[contains(@class, 'files-tabs')]"))
+            {
+                string sectionName = fileSection.Descendants("h2").First().InnerText;
+                if (sectionName != "Main files" && sectionName != "Optional files")
+                    continue;
+
+                rawVersions.AddRange(
+                    from statBox in fileSection.Descendants().Where(p => p.HasClass("stat-version"))
+                    from versionStat in statBox.Descendants().Where(p => p.HasClass("stat"))
+                    select versionStat.InnerText.Trim()
+                );
+            }
+
+            // choose latest file version
+            ISemanticVersion latestFileVersion = null;
+            foreach (string rawVersion in rawVersions)
+            {
+                if (!SemanticVersion.TryParse(rawVersion, out ISemanticVersion cur))
+                    continue;
+                if (parsedVersion != null && !cur.IsNewerThan(parsedVersion))
+                    continue;
+                if (latestFileVersion != null && !cur.IsNewerThan(latestFileVersion))
+                    continue;
+
+                latestFileVersion = cur;
+            }
+
+            // yield info
+            return new NexusMod
+            {
+                Name = name,
+                Version = parsedVersion?.ToString() ?? version,
+                LatestFileVersion = latestFileVersion,
+                Url = url
+            };
+        }
+
+        /// <summary>Get metadata about a mod from the Nexus API.</summary>
+        /// <param name="id">The Nexus mod ID.</param>
+        /// <returns>Returns the mod info if found, else <c>null</c>.</returns>
+        private async Task<NexusMod> GetModFromApiAsync(uint id)
+        {
+            // fetch mod
+            Mod mod = await this.ApiClient.Mods.GetMod("stardewvalley", (int)id);
+            ModFileList files = await this.ApiClient.ModFiles.GetModFiles("stardewvalley", (int)id, FileCategory.Main, FileCategory.Optional);
+
+            // get versions
+            if (!SemanticVersion.TryParse(mod.Version, out ISemanticVersion mainVersion))
+                mainVersion = null;
+            ISemanticVersion latestFileVersion = null;
+            foreach (string rawVersion in files.Files.Select(p => p.FileVersion))
+            {
+                if (!SemanticVersion.TryParse(rawVersion, out ISemanticVersion cur))
+                    continue;
+                if (mainVersion != null && !cur.IsNewerThan(mainVersion))
+                    continue;
+                if (latestFileVersion != null && !cur.IsNewerThan(latestFileVersion))
+                    continue;
+
+                latestFileVersion = cur;
+            }
+
+            // yield info
+            return new NexusMod
+            {
+                Name = mod.Name,
+                Version = SemanticVersion.TryParse(mod.Version, out ISemanticVersion version) ? version?.ToString() : mod.Version,
+                LatestFileVersion = latestFileVersion,
+                Url = this.GetModUrl(id)
+            };
+        }
+
+        /// <summary>Get the full mod page URL for a given ID.</summary>
+        /// <param name="id">The mod ID.</param>
+        private string GetModUrl(uint id)
+        {
+            UriBuilder builder = new UriBuilder(this.WebClient.BaseClient.BaseAddress);
+            builder.Path += string.Format(this.WebModUrlFormat, id);
+            return builder.Uri.ToString();
+        }
+
+        /// <summary>Get the mod status for a web error code.</summary>
+        /// <param name="errorCode">The Nexus error code.</param>
+        private NexusModStatus GetWebStatus(string errorCode)
+        {
+            switch (errorCode.Trim().ToLower())
+            {
+                case "adult content":
+                    return NexusModStatus.AdultContentForbidden;
+
+                case "hidden mod":
+                    return NexusModStatus.Hidden;
+
+                case "not published":
+                    return NexusModStatus.NotPublished;
+
+                default:
+                    return NexusModStatus.Other;
+            }
+        }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Clients/Nexus/NexusMod.cs b/src/SMAPI.Web/Framework/Clients/Nexus/NexusMod.cs
index f4909155..0f1b29d5 100644
--- a/src/SMAPI.Web/Framework/Clients/Nexus/NexusMod.cs
+++ b/src/SMAPI.Web/Framework/Clients/Nexus/NexusMod.cs
@@ -21,6 +21,10 @@ namespace StardewModdingAPI.Web.Framework.Clients.Nexus
         [JsonProperty("mod_page_uri")]
         public string Url { get; set; }
 
+        /// <summary>The mod's publication status.</summary>
+        [JsonIgnore]
+        public NexusModStatus Status { get; set; } = NexusModStatus.Ok;
+
         /// <summary>A user-friendly error which indicates why fetching the mod info failed (if applicable).</summary>
         [JsonIgnore]
         public string Error { get; set; }
diff --git a/src/SMAPI.Web/Framework/Clients/Nexus/NexusModStatus.cs b/src/SMAPI.Web/Framework/Clients/Nexus/NexusModStatus.cs
new file mode 100644
index 00000000..9ef314cd
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Clients/Nexus/NexusModStatus.cs
@@ -0,0 +1,21 @@
+namespace StardewModdingAPI.Web.Framework.Clients.Nexus
+{
+    /// <summary>The status of a Nexus mod.</summary>
+    internal enum NexusModStatus
+    {
+        /// <summary>The mod is published and valid.</summary>
+        Ok,
+
+        /// <summary>The mod is hidden by the author.</summary>
+        Hidden,
+
+        /// <summary>The mod hasn't been published yet.</summary>
+        NotPublished,
+
+        /// <summary>The mod contains adult content which is hidden for anonymous web users.</summary>
+        AdultContentForbidden,
+
+        /// <summary>The Nexus API returned an unhandled error.</summary>
+        Other
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Clients/Nexus/NexusWebScrapeClient.cs b/src/SMAPI.Web/Framework/Clients/Nexus/NexusWebScrapeClient.cs
deleted file mode 100644
index e83a6041..00000000
--- a/src/SMAPI.Web/Framework/Clients/Nexus/NexusWebScrapeClient.cs
+++ /dev/null
@@ -1,146 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Net;
-using System.Threading.Tasks;
-using HtmlAgilityPack;
-using Pathoschild.Http.Client;
-using StardewModdingAPI.Toolkit;
-
-namespace StardewModdingAPI.Web.Framework.Clients.Nexus
-{
-    /// <summary>An HTTP client for fetching mod metadata from the Nexus website.</summary>
-    internal class NexusWebScrapeClient : INexusClient
-    {
-        /*********
-        ** Fields
-        *********/
-        /// <summary>The URL for a Nexus mod page for the user, excluding the base URL, where {0} is the mod ID.</summary>
-        private readonly string ModUrlFormat;
-
-        /// <summary>The URL for a Nexus mod page to scrape for versions, excluding the base URL, where {0} is the mod ID.</summary>
-        public string ModScrapeUrlFormat { get; set; }
-
-        /// <summary>The underlying HTTP client.</summary>
-        private readonly IClient Client;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Construct an instance.</summary>
-        /// <param name="userAgent">The user agent for the Nexus Mods API client.</param>
-        /// <param name="baseUrl">The base URL for the Nexus Mods site.</param>
-        /// <param name="modUrlFormat">The URL for a Nexus Mods mod page for the user, excluding the <paramref name="baseUrl"/>, where {0} is the mod ID.</param>
-        /// <param name="modScrapeUrlFormat">The URL for a Nexus mod page to scrape for versions, excluding the base URL, where {0} is the mod ID.</param>
-        public NexusWebScrapeClient(string userAgent, string baseUrl, string modUrlFormat, string modScrapeUrlFormat)
-        {
-            this.ModUrlFormat = modUrlFormat;
-            this.ModScrapeUrlFormat = modScrapeUrlFormat;
-            this.Client = new FluentClient(baseUrl).SetUserAgent(userAgent);
-        }
-
-        /// <summary>Get metadata about a mod.</summary>
-        /// <param name="id">The Nexus mod ID.</param>
-        /// <returns>Returns the mod info if found, else <c>null</c>.</returns>
-        public async Task<NexusMod> GetModAsync(uint id)
-        {
-            // fetch HTML
-            string html;
-            try
-            {
-                html = await this.Client
-                    .GetAsync(string.Format(this.ModScrapeUrlFormat, id))
-                    .AsString();
-            }
-            catch (ApiException ex) when (ex.Status == HttpStatusCode.NotFound)
-            {
-                return null;
-            }
-
-            // parse HTML
-            var doc = new HtmlDocument();
-            doc.LoadHtml(html);
-
-            // handle Nexus error message
-            HtmlNode node = doc.DocumentNode.SelectSingleNode("//div[contains(@class, 'site-notice')][contains(@class, 'warning')]");
-            if (node != null)
-            {
-                string[] errorParts = node.InnerText.Trim().Split(new[] { '\n' }, 2, System.StringSplitOptions.RemoveEmptyEntries);
-                string errorCode = errorParts[0];
-                string errorText = errorParts.Length > 1 ? errorParts[1] : null;
-                switch (errorCode.Trim().ToLower())
-                {
-                    case "not found":
-                        return null;
-
-                    default:
-                        return new NexusMod { Error = $"Nexus error: {errorCode} ({errorText})." };
-                }
-            }
-
-            // extract mod info
-            string url = this.GetModUrl(id);
-            string name = doc.DocumentNode.SelectSingleNode("//h1")?.InnerText.Trim();
-            string version = doc.DocumentNode.SelectSingleNode("//ul[contains(@class, 'stats')]//li[@class='stat-version']//div[@class='stat']")?.InnerText.Trim();
-            SemanticVersion.TryParse(version, out ISemanticVersion parsedVersion);
-
-            // extract file versions
-            List<string> rawVersions = new List<string>();
-            foreach (var fileSection in doc.DocumentNode.SelectNodes("//div[contains(@class, 'files-tabs')]"))
-            {
-                string sectionName = fileSection.Descendants("h2").First().InnerText;
-                if (sectionName != "Main files" && sectionName != "Optional files")
-                    continue;
-
-                rawVersions.AddRange(
-                    from statBox in fileSection.Descendants().Where(p => p.HasClass("stat-version"))
-                    from versionStat in statBox.Descendants().Where(p => p.HasClass("stat"))
-                    select versionStat.InnerText.Trim()
-                );
-            }
-
-            // choose latest file version
-            ISemanticVersion latestFileVersion = null;
-            foreach (string rawVersion in rawVersions)
-            {
-                if (!SemanticVersion.TryParse(rawVersion, out ISemanticVersion cur))
-                    continue;
-                if (parsedVersion != null && !cur.IsNewerThan(parsedVersion))
-                    continue;
-                if (latestFileVersion != null && !cur.IsNewerThan(latestFileVersion))
-                    continue;
-
-                latestFileVersion = cur;
-            }
-
-            // yield info
-            return new NexusMod
-            {
-                Name = name,
-                Version = parsedVersion?.ToString() ?? version,
-                LatestFileVersion = latestFileVersion,
-                Url = url
-            };
-        }
-
-        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
-        public void Dispose()
-        {
-            this.Client?.Dispose();
-        }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Get the full mod page URL for a given ID.</summary>
-        /// <param name="id">The mod ID.</param>
-        private string GetModUrl(uint id)
-        {
-            UriBuilder builder = new UriBuilder(this.Client.BaseClient.BaseAddress);
-            builder.Path += string.Format(this.ModUrlFormat, id);
-            return builder.Uri.ToString();
-        }
-    }
-}
diff --git a/src/SMAPI.Web/Framework/Clients/Pastebin/IPastebinClient.cs b/src/SMAPI.Web/Framework/Clients/Pastebin/IPastebinClient.cs
index 630dfb76..a635abe3 100644
--- a/src/SMAPI.Web/Framework/Clients/Pastebin/IPastebinClient.cs
+++ b/src/SMAPI.Web/Framework/Clients/Pastebin/IPastebinClient.cs
@@ -11,7 +11,8 @@ namespace StardewModdingAPI.Web.Framework.Clients.Pastebin
         Task<PasteInfo> GetAsync(string id);
 
         /// <summary>Save a paste to Pastebin.</summary>
+        /// <param name="name">The paste name.</param>
         /// <param name="content">The paste content.</param>
-        Task<SavePasteResult> PostAsync(string content);
+        Task<SavePasteResult> PostAsync(string name, string content);
     }
 }
diff --git a/src/SMAPI.Web/Framework/Clients/Pastebin/PastebinClient.cs b/src/SMAPI.Web/Framework/Clients/Pastebin/PastebinClient.cs
index 12c3e83f..2e8a8c68 100644
--- a/src/SMAPI.Web/Framework/Clients/Pastebin/PastebinClient.cs
+++ b/src/SMAPI.Web/Framework/Clients/Pastebin/PastebinClient.cs
@@ -1,11 +1,8 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Net;
 using System.Net.Http;
-using System.Text;
 using System.Threading.Tasks;
-using System.Web;
 using Pathoschild.Http.Client;
 
 namespace StardewModdingAPI.Web.Framework.Clients.Pastebin
@@ -70,8 +67,9 @@ namespace StardewModdingAPI.Web.Framework.Clients.Pastebin
         }
 
         /// <summary>Save a paste to Pastebin.</summary>
+        /// <param name="name">The paste name.</param>
         /// <param name="content">The paste content.</param>
-        public async Task<SavePasteResult> PostAsync(string content)
+        public async Task<SavePasteResult> PostAsync(string name, string content)
         {
             try
             {
@@ -82,15 +80,15 @@ namespace StardewModdingAPI.Web.Framework.Clients.Pastebin
                 // post to API
                 string response = await this.Client
                     .PostAsync("api/api_post.php")
-                    .WithBodyContent(this.GetFormUrlEncodedContent(new Dictionary<string, string>
+                    .WithBody(p => p.FormUrlEncoded(new
                     {
-                        ["api_option"] = "paste",
-                        ["api_user_key"] = this.UserKey,
-                        ["api_dev_key"] = this.DevKey,
-                        ["api_paste_private"] = "1", // unlisted
-                        ["api_paste_name"] = $"SMAPI log {DateTime.UtcNow:s}",
-                        ["api_paste_expire_date"] = "N", // never expire
-                        ["api_paste_code"] = content
+                        api_option = "paste",
+                        api_user_key = this.UserKey,
+                        api_dev_key = this.DevKey,
+                        api_paste_private = 1, // unlisted
+                        api_paste_name = name,
+                        api_paste_expire_date = "N", // never expire
+                        api_paste_code = content
                     }))
                     .AsString();
 
@@ -117,18 +115,5 @@ namespace StardewModdingAPI.Web.Framework.Clients.Pastebin
         {
             this.Client.Dispose();
         }
-
-
-        /*********
-        ** Private methods
-        *********/
-        /// <summary>Build an HTTP content body with form-url-encoded content.</summary>
-        /// <param name="data">The content to encode.</param>
-        /// <remarks>This bypasses an issue where <see cref="FormUrlEncodedContent"/> restricts the body length to the maximum size of a URL, which isn't applicable here.</remarks>
-        private HttpContent GetFormUrlEncodedContent(IDictionary<string, string> data)
-        {
-            string body = string.Join("&", from arg in data select $"{HttpUtility.UrlEncode(arg.Key)}={HttpUtility.UrlEncode(arg.Value)}");
-            return new StringContent(body, Encoding.UTF8, "application/x-www-form-urlencoded");
-        }
     }
 }
diff --git a/src/SMAPI.Web/Framework/Compression/GzipHelper.cs b/src/SMAPI.Web/Framework/Compression/GzipHelper.cs
new file mode 100644
index 00000000..cc8f4737
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Compression/GzipHelper.cs
@@ -0,0 +1,89 @@
+using System;
+using System.IO;
+using System.IO.Compression;
+using System.Text;
+
+namespace StardewModdingAPI.Web.Framework.Compression
+{
+    /// <summary>Handles GZip compression logic.</summary>
+    internal class GzipHelper : IGzipHelper
+    {
+        /*********
+        ** Fields
+        *********/
+        /// <summary>The first bytes in a valid zip file.</summary>
+        /// <remarks>See <a href="https://en.wikipedia.org/wiki/Zip_(file_format)#File_headers"/>.</remarks>
+        private const uint GzipLeadBytes = 0x8b1f;
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Compress a string.</summary>
+        /// <param name="text">The text to compress.</param>
+        /// <remarks>Derived from <a href="https://stackoverflow.com/a/17993002/262123"/>.</remarks>
+        public string CompressString(string text)
+        {
+            // get raw bytes
+            byte[] buffer = Encoding.UTF8.GetBytes(text);
+
+            // compressed
+            byte[] compressedData;
+            using (MemoryStream stream = new MemoryStream())
+            {
+                using (GZipStream zipStream = new GZipStream(stream, CompressionLevel.Optimal, leaveOpen: true))
+                    zipStream.Write(buffer, 0, buffer.Length);
+
+                stream.Position = 0;
+                compressedData = new byte[stream.Length];
+                stream.Read(compressedData, 0, compressedData.Length);
+            }
+
+            // prefix length
+            byte[] zipBuffer = new byte[compressedData.Length + 4];
+            Buffer.BlockCopy(compressedData, 0, zipBuffer, 4, compressedData.Length);
+            Buffer.BlockCopy(BitConverter.GetBytes(buffer.Length), 0, zipBuffer, 0, 4);
+
+            // return string representation
+            return Convert.ToBase64String(zipBuffer);
+        }
+
+        /// <summary>Decompress a string.</summary>
+        /// <param name="rawText">The compressed text.</param>
+        /// <remarks>Derived from <a href="https://stackoverflow.com/a/17993002/262123"/>.</remarks>
+        public string DecompressString(string rawText)
+        {
+            // get raw bytes
+            byte[] zipBuffer;
+            try
+            {
+                zipBuffer = Convert.FromBase64String(rawText);
+            }
+            catch
+            {
+                return rawText; // not valid base64, wasn't compressed by the log parser
+            }
+
+            // skip if not gzip
+            if (BitConverter.ToUInt16(zipBuffer, 4) != GzipHelper.GzipLeadBytes)
+                return rawText;
+
+            // decompress
+            using (MemoryStream memoryStream = new MemoryStream())
+            {
+                // read length prefix
+                int dataLength = BitConverter.ToInt32(zipBuffer, 0);
+                memoryStream.Write(zipBuffer, 4, zipBuffer.Length - 4);
+
+                // read data
+                byte[] buffer = new byte[dataLength];
+                memoryStream.Position = 0;
+                using (GZipStream gZipStream = new GZipStream(memoryStream, CompressionMode.Decompress))
+                    gZipStream.Read(buffer, 0, buffer.Length);
+
+                // return original string
+                return Encoding.UTF8.GetString(buffer);
+            }
+        }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/Compression/IGzipHelper.cs b/src/SMAPI.Web/Framework/Compression/IGzipHelper.cs
new file mode 100644
index 00000000..a000865e
--- /dev/null
+++ b/src/SMAPI.Web/Framework/Compression/IGzipHelper.cs
@@ -0,0 +1,17 @@
+namespace StardewModdingAPI.Web.Framework.Compression
+{
+    /// <summary>Handles GZip compression logic.</summary>
+    internal interface IGzipHelper
+    {
+        /*********
+        ** Methods
+        *********/
+        /// <summary>Compress a string.</summary>
+        /// <param name="text">The text to compress.</param>
+        string CompressString(string text);
+
+        /// <summary>Decompress a string.</summary>
+        /// <param name="rawText">The compressed text.</param>
+        string DecompressString(string rawText);
+    }
+}
diff --git a/src/SMAPI.Web/Framework/ConfigModels/ApiClientsConfig.cs b/src/SMAPI.Web/Framework/ConfigModels/ApiClientsConfig.cs
index c27cadab..121690c5 100644
--- a/src/SMAPI.Web/Framework/ConfigModels/ApiClientsConfig.cs
+++ b/src/SMAPI.Web/Framework/ConfigModels/ApiClientsConfig.cs
@@ -24,17 +24,18 @@ namespace StardewModdingAPI.Web.Framework.ConfigModels
 
 
         /****
+        ** CurseForge
+        ****/
+        /// <summary>The base URL for the CurseForge API.</summary>
+        public string CurseForgeBaseUrl { get; set; }
+
+
+        /****
         ** GitHub
         ****/
         /// <summary>The base URL for the GitHub API.</summary>
         public string GitHubBaseUrl { get; set; }
 
-        /// <summary>The URL for a GitHub API query for the latest stable release, excluding the <see cref="GitHubBaseUrl"/>, where {0} is the organisation and project name.</summary>
-        public string GitHubStableReleaseUrlFormat { get; set; }
-
-        /// <summary>The URL for a GitHub API query for the latest release (including prerelease), excluding the <see cref="GitHubBaseUrl"/>, where {0} is the organisation and project name.</summary>
-        public string GitHubAnyReleaseUrlFormat { get; set; }
-
         /// <summary>The Accept header value expected by the GitHub API.</summary>
         public string GitHubAcceptHeader { get; set; }
 
@@ -65,6 +66,9 @@ namespace StardewModdingAPI.Web.Framework.ConfigModels
         /// <summary>The URL for a Nexus mod page to scrape for versions, excluding the <see cref="NexusBaseUrl"/>, where {0} is the mod ID.</summary>
         public string NexusModScrapeUrlFormat { get; set; }
 
+        /// <summary>The Nexus API authentication key.</summary>
+        public string NexusApiKey { get; set; }
+
         /****
         ** Pastebin
         ****/
diff --git a/src/SMAPI.Web/Framework/ConfigModels/BackgroundServicesConfig.cs b/src/SMAPI.Web/Framework/ConfigModels/BackgroundServicesConfig.cs
new file mode 100644
index 00000000..de871c9a
--- /dev/null
+++ b/src/SMAPI.Web/Framework/ConfigModels/BackgroundServicesConfig.cs
@@ -0,0 +1,12 @@
+namespace StardewModdingAPI.Web.Framework.ConfigModels
+{
+    /// <summary>The config settings for background services.</summary>
+    internal class BackgroundServicesConfig
+    {
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>Whether to enable background update services.</summary>
+        public bool Enabled { get; set; }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/ConfigModels/ModCompatibilityListConfig.cs b/src/SMAPI.Web/Framework/ConfigModels/ModCompatibilityListConfig.cs
index d9ac9f02..24b540cd 100644
--- a/src/SMAPI.Web/Framework/ConfigModels/ModCompatibilityListConfig.cs
+++ b/src/SMAPI.Web/Framework/ConfigModels/ModCompatibilityListConfig.cs
@@ -1,12 +1,12 @@
 namespace StardewModdingAPI.Web.Framework.ConfigModels
 {
-    /// <summary>The config settings for mod compatibility list.</summary>
+    /// <summary>The config settings for the mod compatibility list.</summary>
     internal class ModCompatibilityListConfig
     {
         /*********
         ** Accessors
         *********/
-        /// <summary>The number of minutes data from the wiki should be cached before refetching it.</summary>
-        public int CacheMinutes { get; set; }
+        /// <summary>The number of minutes before which wiki data should be considered old.</summary>
+        public int StaleMinutes { get; set; }
     }
 }
diff --git a/src/SMAPI.Web/Framework/ConfigModels/ModUpdateCheckConfig.cs b/src/SMAPI.Web/Framework/ConfigModels/ModUpdateCheckConfig.cs
index bde566c0..ab935bb3 100644
--- a/src/SMAPI.Web/Framework/ConfigModels/ModUpdateCheckConfig.cs
+++ b/src/SMAPI.Web/Framework/ConfigModels/ModUpdateCheckConfig.cs
@@ -12,10 +12,6 @@ namespace StardewModdingAPI.Web.Framework.ConfigModels
         /// <summary>The number of minutes failed update checks should be cached before refetching them.</summary>
         public int ErrorCacheMinutes { get; set; }
 
-        /// <summary>A regex which matches SMAPI-style semantic version.</summary>
-        /// <remarks>Derived from SMAPI's SemanticVersion implementation.</remarks>
-        public string SemanticVersionRegex { get; set; }
-
         /// <summary>The web URL for the wiki compatibility list.</summary>
         public string CompatibilityPageUrl { get; set; }
     }
diff --git a/src/SMAPI.Web/Framework/ConfigModels/MongoDbConfig.cs b/src/SMAPI.Web/Framework/ConfigModels/MongoDbConfig.cs
new file mode 100644
index 00000000..3c508300
--- /dev/null
+++ b/src/SMAPI.Web/Framework/ConfigModels/MongoDbConfig.cs
@@ -0,0 +1,38 @@
+using System;
+
+namespace StardewModdingAPI.Web.Framework.ConfigModels
+{
+    /// <summary>The config settings for mod compatibility list.</summary>
+    internal class MongoDbConfig
+    {
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>The MongoDB hostname.</summary>
+        public string Host { get; set; }
+
+        /// <summary>The MongoDB username (if any).</summary>
+        public string Username { get; set; }
+
+        /// <summary>The MongoDB password (if any).</summary>
+        public string Password { get; set; }
+
+        /// <summary>The database name.</summary>
+        public string Database { get; set; }
+
+
+        /*********
+        ** Public method
+        *********/
+        /// <summary>Get the MongoDB connection string.</summary>
+        public string GetConnectionString()
+        {
+            bool isLocal = this.Host == "localhost";
+            bool hasLogin = !string.IsNullOrWhiteSpace(this.Username) && !string.IsNullOrWhiteSpace(this.Password);
+
+            return $"mongodb{(isLocal ? "" : "+srv")}://"
+                + (hasLogin ? $"{Uri.EscapeDataString(this.Username)}:{Uri.EscapeDataString(this.Password)}@" : "")
+                + $"{this.Host}/{this.Database}?retryWrites=true&w=majority";
+        }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/ConfigModels/SiteConfig.cs b/src/SMAPI.Web/Framework/ConfigModels/SiteConfig.cs
index d89a4260..bc6e868a 100644
--- a/src/SMAPI.Web/Framework/ConfigModels/SiteConfig.cs
+++ b/src/SMAPI.Web/Framework/ConfigModels/SiteConfig.cs
@@ -12,6 +12,9 @@ namespace StardewModdingAPI.Web.Framework.ConfigModels
         /// <summary>The root URL for the log parser.</summary>
         public string LogParserUrl { get; set; }
 
+        /// <summary>The root URL for the JSON validator.</summary>
+        public string JsonValidatorUrl { get; set; }
+
         /// <summary>The root URL for the mod list.</summary>
         public string ModListUrl { get; set; }
 
diff --git a/src/SMAPI.Web/Framework/JobDashboardAuthorizationFilter.cs b/src/SMAPI.Web/Framework/JobDashboardAuthorizationFilter.cs
new file mode 100644
index 00000000..385c0c91
--- /dev/null
+++ b/src/SMAPI.Web/Framework/JobDashboardAuthorizationFilter.cs
@@ -0,0 +1,34 @@
+using Hangfire.Dashboard;
+
+namespace StardewModdingAPI.Web.Framework
+{
+    /// <summary>Authorizes requests to access the Hangfire job dashboard.</summary>
+    internal class JobDashboardAuthorizationFilter : IDashboardAuthorizationFilter
+    {
+        /*********
+        ** Fields
+        *********/
+        /// <summary>An authorization filter that allows local requests.</summary>
+        private static readonly LocalRequestsOnlyAuthorizationFilter LocalRequestsOnlyFilter = new LocalRequestsOnlyAuthorizationFilter();
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Authorize a request.</summary>
+        /// <param name="context">The dashboard context.</param>
+        public bool Authorize(DashboardContext context)
+        {
+            return
+                context.IsReadOnly // always allow readonly access
+                || JobDashboardAuthorizationFilter.IsLocalRequest(context); // else allow access from localhost
+        }
+
+        /// <summary>Get whether a request originated from a user on the server machine.</summary>
+        /// <param name="context">The dashboard context.</param>
+        public static bool IsLocalRequest(DashboardContext context)
+        {
+            return JobDashboardAuthorizationFilter.LocalRequestsOnlyFilter.Authorize(context);
+        }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/LogParsing/LogParser.cs b/src/SMAPI.Web/Framework/LogParsing/LogParser.cs
index 595e6b49..66a3687f 100644
--- a/src/SMAPI.Web/Framework/LogParsing/LogParser.cs
+++ b/src/SMAPI.Web/Framework/LogParsing/LogParser.cs
@@ -221,7 +221,7 @@ namespace StardewModdingAPI.Web.Framework.LogParsing
                     }
                 }
 
-                // finalise log
+                // finalize log
                 gameMod.Version = log.GameVersion;
                 log.Mods = new[] { gameMod, smapiMod }.Concat(mods.Values.OrderBy(p => p.Name)).ToArray();
                 return log;
diff --git a/src/SMAPI.Web/Framework/ModRepositories/BaseRepository.cs b/src/SMAPI.Web/Framework/ModRepositories/BaseRepository.cs
index 94256005..f9f9f47d 100644
--- a/src/SMAPI.Web/Framework/ModRepositories/BaseRepository.cs
+++ b/src/SMAPI.Web/Framework/ModRepositories/BaseRepository.cs
@@ -34,9 +34,9 @@ namespace StardewModdingAPI.Web.Framework.ModRepositories
             this.VendorKey = vendorKey;
         }
 
-        /// <summary>Normalise a version string.</summary>
-        /// <param name="version">The version to normalise.</param>
-        protected string NormaliseVersion(string version)
+        /// <summary>Normalize a version string.</summary>
+        /// <param name="version">The version to normalize.</param>
+        protected string NormalizeVersion(string version)
         {
             if (string.IsNullOrWhiteSpace(version))
                 return null;
diff --git a/src/SMAPI.Web/Framework/ModRepositories/ChucklefishRepository.cs b/src/SMAPI.Web/Framework/ModRepositories/ChucklefishRepository.cs
index 87e29a2f..0945735a 100644
--- a/src/SMAPI.Web/Framework/ModRepositories/ChucklefishRepository.cs
+++ b/src/SMAPI.Web/Framework/ModRepositories/ChucklefishRepository.cs
@@ -32,21 +32,19 @@ namespace StardewModdingAPI.Web.Framework.ModRepositories
         {
             // validate ID format
             if (!uint.TryParse(id, out uint realID))
-                return new ModInfoModel($"The value '{id}' isn't a valid Chucklefish mod ID, must be an integer ID.");
+                return new ModInfoModel().SetError(RemoteModStatus.DoesNotExist, $"The value '{id}' isn't a valid Chucklefish mod ID, must be an integer ID.");
 
             // fetch info
             try
             {
                 var mod = await this.Client.GetModAsync(realID);
-                if (mod == null)
-                    return new ModInfoModel("Found no mod with this ID.");
-
-                // create model
-                return new ModInfoModel(name: mod.Name, version: this.NormaliseVersion(mod.Version), url: mod.Url);
+                return mod != null
+                    ? new ModInfoModel(name: mod.Name, version: this.NormalizeVersion(mod.Version), url: mod.Url)
+                    : new ModInfoModel().SetError(RemoteModStatus.DoesNotExist, "Found no Chucklefish mod with this ID.");
             }
             catch (Exception ex)
             {
-                return new ModInfoModel(ex.ToString());
+                return new ModInfoModel().SetError(RemoteModStatus.TemporaryError, ex.ToString());
             }
         }
 
diff --git a/src/SMAPI.Web/Framework/ModRepositories/CurseForgeRepository.cs b/src/SMAPI.Web/Framework/ModRepositories/CurseForgeRepository.cs
new file mode 100644
index 00000000..93ddc1eb
--- /dev/null
+++ b/src/SMAPI.Web/Framework/ModRepositories/CurseForgeRepository.cs
@@ -0,0 +1,63 @@
+using System;
+using System.Threading.Tasks;
+using StardewModdingAPI.Toolkit.Framework.UpdateData;
+using StardewModdingAPI.Web.Framework.Clients.CurseForge;
+
+namespace StardewModdingAPI.Web.Framework.ModRepositories
+{
+    /// <summary>An HTTP client for fetching mod metadata from CurseForge.</summary>
+    internal class CurseForgeRepository : RepositoryBase
+    {
+        /*********
+        ** Fields
+        *********/
+        /// <summary>The underlying CurseForge API client.</summary>
+        private readonly ICurseForgeClient Client;
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="client">The underlying CurseForge API client.</param>
+        public CurseForgeRepository(ICurseForgeClient client)
+            : base(ModRepositoryKey.CurseForge)
+        {
+            this.Client = client;
+        }
+
+        /// <summary>Get metadata about a mod in the repository.</summary>
+        /// <param name="id">The mod ID in this repository.</param>
+        public override async Task<ModInfoModel> GetModInfoAsync(string id)
+        {
+            // validate ID format
+            if (!uint.TryParse(id, out uint curseID))
+                return new ModInfoModel().SetError(RemoteModStatus.DoesNotExist, $"The value '{id}' isn't a valid CurseForge mod ID, must be an integer ID.");
+
+            // fetch info
+            try
+            {
+                CurseForgeMod mod = await this.Client.GetModAsync(curseID);
+                if (mod == null)
+                    return new ModInfoModel().SetError(RemoteModStatus.DoesNotExist, "Found no CurseForge mod with this ID.");
+                if (mod.Error != null)
+                {
+                    RemoteModStatus remoteStatus = RemoteModStatus.InvalidData;
+                    return new ModInfoModel().SetError(remoteStatus, mod.Error);
+                }
+
+                return new ModInfoModel(name: mod.Name, version: this.NormalizeVersion(mod.LatestVersion), url: mod.Url);
+            }
+            catch (Exception ex)
+            {
+                return new ModInfoModel().SetError(RemoteModStatus.TemporaryError, ex.ToString());
+            }
+        }
+
+        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
+        public override void Dispose()
+        {
+            this.Client.Dispose();
+        }
+    }
+}
diff --git a/src/SMAPI.Web/Framework/ModRepositories/GitHubRepository.cs b/src/SMAPI.Web/Framework/ModRepositories/GitHubRepository.cs
index 14f44dc0..c62cb73f 100644
--- a/src/SMAPI.Web/Framework/ModRepositories/GitHubRepository.cs
+++ b/src/SMAPI.Web/Framework/ModRepositories/GitHubRepository.cs
@@ -30,36 +30,46 @@ namespace StardewModdingAPI.Web.Framework.ModRepositories
         /// <param name="id">The mod ID in this repository.</param>
         public override async Task<ModInfoModel> GetModInfoAsync(string id)
         {
+            ModInfoModel result = new ModInfoModel().SetBasicInfo(id, $"https://github.com/{id}/releases");
+
             // validate ID format
             if (!id.Contains("/") || id.IndexOf("/", StringComparison.InvariantCultureIgnoreCase) != id.LastIndexOf("/", StringComparison.InvariantCultureIgnoreCase))
-                return new ModInfoModel($"The value '{id}' isn't a valid GitHub mod ID, must be a username and project name like 'Pathoschild/LookupAnything'.");
+                return result.SetError(RemoteModStatus.DoesNotExist, $"The value '{id}' isn't a valid GitHub mod ID, must be a username and project name like 'Pathoschild/LookupAnything'.");
 
             // fetch info
             try
             {
+                // fetch repo info
+                GitRepo repository = await this.Client.GetRepositoryAsync(id);
+                if (repository == null)
+                    return result.SetError(RemoteModStatus.DoesNotExist, "Found no GitHub repository for this ID.");
+                result
+                    .SetBasicInfo(repository.FullName, $"{repository.WebUrl}/releases")
+                    .SetLicense(url: repository.License?.Url, name: repository.License?.SpdxId ?? repository.License?.Name);
+
                 // get latest release (whether preview or stable)
                 GitRelease latest = await this.Client.GetLatestReleaseAsync(id, includePrerelease: true);
                 if (latest == null)
-                    return new ModInfoModel("Found no mod with this ID.");
+                    return result.SetError(RemoteModStatus.DoesNotExist, "Found no GitHub release for this ID.");
 
                 // split stable/prerelease if applicable
                 GitRelease preview = null;
                 if (latest.IsPrerelease)
                 {
-                    GitRelease result = await this.Client.GetLatestReleaseAsync(id, includePrerelease: false);
-                    if (result != null)
+                    GitRelease release = await this.Client.GetLatestReleaseAsync(id, includePrerelease: false);
+                    if (release != null)
                     {
                         preview = latest;
-                        latest = result;
+                        latest = release;
                     }
                 }
 
                 // return data
-                return new ModInfoModel(name: id, version: this.NormaliseVersion(latest.Tag), previewVersion: this.NormaliseVersion(preview?.Tag), url: $"https://github.com/{id}/releases");
+                return result.SetVersions(version: this.NormalizeVersion(latest.Tag), previewVersion: this.NormalizeVersion(preview?.Tag));
             }
             catch (Exception ex)
             {
-                return new ModInfoModel(ex.ToString());
+                return result.SetError(RemoteModStatus.TemporaryError, ex.ToString());
             }
         }
 
diff --git a/src/SMAPI.Web/Framework/ModRepositories/ModDropRepository.cs b/src/SMAPI.Web/Framework/ModRepositories/ModDropRepository.cs
index 1994f515..62142668 100644
--- a/src/SMAPI.Web/Framework/ModRepositories/ModDropRepository.cs
+++ b/src/SMAPI.Web/Framework/ModRepositories/ModDropRepository.cs
@@ -32,21 +32,19 @@ namespace StardewModdingAPI.Web.Framework.ModRepositories
         {
             // validate ID format
             if (!long.TryParse(id, out long modDropID))
-                return new ModInfoModel($"The value '{id}' isn't a valid ModDrop mod ID, must be an integer ID.");
+                return new ModInfoModel().SetError(RemoteModStatus.DoesNotExist, $"The value '{id}' isn't a valid ModDrop mod ID, must be an integer ID.");
 
             // fetch info
             try
             {
                 ModDropMod mod = await this.Client.GetModAsync(modDropID);
-                if (mod == null)
-                    return new ModInfoModel("Found no mod with this ID.");
-                if (mod.Error != null)
-                    return new ModInfoModel(mod.Error);
-                return new ModInfoModel(name: mod.Name, version: mod.LatestDefaultVersion?.ToString(), previewVersion: mod.LatestOptionalVersion?.ToString(), url: mod.Url);
+                return mod != null
+                    ? new ModInfoModel(name: mod.Name, version: mod.LatestDefaultVersion?.ToString(), previewVersion: mod.LatestOptionalVersion?.ToString(), url: mod.Url)
+                    : new ModInfoModel().SetError(RemoteModStatus.DoesNotExist, "Found no ModDrop mod with this ID.");
             }
             catch (Exception ex)
             {
-                return new ModInfoModel(ex.ToString());
+                return new ModInfoModel().SetError(RemoteModStatus.TemporaryError, ex.ToString());
             }
         }
 
diff --git a/src/SMAPI.Web/Framework/ModRepositories/ModInfoModel.cs b/src/SMAPI.Web/Framework/ModRepositories/ModInfoModel.cs
index 18252298..46b98860 100644
--- a/src/SMAPI.Web/Framework/ModRepositories/ModInfoModel.cs
+++ b/src/SMAPI.Web/Framework/ModRepositories/ModInfoModel.cs
@@ -9,15 +9,24 @@ namespace StardewModdingAPI.Web.Framework.ModRepositories
         /// <summary>The mod name.</summary>
         public string Name { get; set; }
 
-        /// <summary>The mod's latest release number.</summary>
+        /// <summary>The mod's latest version.</summary>
         public string Version { get; set; }
 
-        /// <summary>The mod's latest optional release, if newer than <see cref="Version"/>.</summary>
+        /// <summary>The mod's latest optional or prerelease version, if newer than <see cref="Version"/>.</summary>
         public string PreviewVersion { get; set; }
 
         /// <summary>The mod's web URL.</summary>
         public string Url { get; set; }
 
+        /// <summary>The license URL, if available.</summary>
+        public string LicenseUrl { get; set; }
+
+        /// <summary>The license name, if available.</summary>
+        public string LicenseName { get; set; }
+
+        /// <summary>The mod availability status on the remote site.</summary>
+        public RemoteModStatus Status { get; set; } = RemoteModStatus.Ok;
+
         /// <summary>The error message indicating why the mod is invalid (if applicable).</summary>
         public string Error { get; set; }
 
@@ -26,31 +35,62 @@ namespace StardewModdingAPI.Web.Framework.ModRepositories
         ** Public methods
         *********/
         /// <summary>Construct an empty instance.</summary>
-        public ModInfoModel()
-        {
-            // needed for JSON deserialising
-        }
+        public ModInfoModel() { }
 
         /// <summary>Construct an instance.</summary>
         /// <param name="name">The mod name.</param>
         /// <param name="version">The semantic version for the mod's latest release.</param>
         /// <param name="previewVersion">The semantic version for the mod's latest preview release, if available and different from <see cref="Version"/>.</param>
         /// <param name="url">The mod's web URL.</param>
-        /// <param name="error">The error message indicating why the mod is invalid (if applicable).</param>
-        public ModInfoModel(string name, string version, string url, string previewVersion = null, string error = null)
+        public ModInfoModel(string name, string version, string url, string previewVersion = null)
+        {
+            this
+                .SetBasicInfo(name, url)
+                .SetVersions(version, previewVersion);
+        }
+
+        /// <summary>Set the basic mod info.</summary>
+        /// <param name="name">The mod name.</param>
+        /// <param name="url">The mod's web URL.</param>
+        public ModInfoModel SetBasicInfo(string name, string url)
         {
             this.Name = name;
+            this.Url = url;
+
+            return this;
+        }
+
+        /// <summary>Set the mod version info.</summary>
+        /// <param name="version">The semantic version for the mod's latest release.</param>
+        /// <param name="previewVersion">The semantic version for the mod's latest preview release, if available and different from <see cref="Version"/>.</param>
+        public ModInfoModel SetVersions(string version, string previewVersion = null)
+        {
             this.Version = version;
             this.PreviewVersion = previewVersion;
-            this.Url = url;
-            this.Error = error;
+
+            return this;
         }
 
-        /// <summary>Construct an instance.</summary>
-        /// <param name="error">The error message indicating why the mod is invalid.</param>
-        public ModInfoModel(string error)
+        /// <summary>Set the license info, if available.</summary>
+        /// <param name="url">The license URL.</param>
+        /// <param name="name">The license name.</param>
+        public ModInfoModel SetLicense(string url, string name)
         {
+            this.LicenseUrl = url;
+            this.LicenseName = name;
+
+            return this;
+        }
+
+        /// <summary>Set a mod error.</summary>
+        /// <param name="status">The mod availability status on the remote site.</param>
+        /// <param name="error">The error message indicating why the mod is invalid (if applicable).</param>
+        public ModInfoModel SetError(RemoteModStatus status, string error)
+        {
+            this.Status = status;
             this.Error = error;
+
+            return this;
         }
     }
 }
diff --git a/src/SMAPI.Web/Framework/ModRepositories/NexusRepository.cs b/src/SMAPI.Web/Framework/ModRepositories/NexusRepository.cs
index 4c5fe9bf..9551258c 100644
--- a/src/SMAPI.Web/Framework/ModRepositories/NexusRepository.cs
+++ b/src/SMAPI.Web/Framework/ModRepositories/NexusRepository.cs
@@ -32,21 +32,27 @@ namespace StardewModdingAPI.Web.Framework.ModRepositories
         {
             // validate ID format
             if (!uint.TryParse(id, out uint nexusID))
-                return new ModInfoModel($"The value '{id}' isn't a valid Nexus mod ID, must be an integer ID.");
+                return new ModInfoModel().SetError(RemoteModStatus.DoesNotExist, $"The value '{id}' isn't a valid Nexus mod ID, must be an integer ID.");
 
             // fetch info
             try
             {
                 NexusMod mod = await this.Client.GetModAsync(nexusID);
                 if (mod == null)
-                    return new ModInfoModel("Found no mod with this ID.");
+                    return new ModInfoModel().SetError(RemoteModStatus.DoesNotExist, "Found no Nexus mod with this ID.");
                 if (mod.Error != null)
-                    return new ModInfoModel(mod.Error);
-                return new ModInfoModel(name: mod.Name, version: this.NormaliseVersion(mod.Version), previewVersion: mod.LatestFileVersion?.ToString(), url: mod.Url);
+                {
+                    RemoteModStatus remoteStatus = mod.Status == NexusModStatus.Hidden || mod.Status == NexusModStatus.NotPublished
+                        ? RemoteModStatus.DoesNotExist
+                        : RemoteModStatus.TemporaryError;
+                    return new ModInfoModel().SetError(remoteStatus, mod.Error);
+                }
+
+                return new ModInfoModel(name: mod.Name, version: this.NormalizeVersion(mod.Version), previewVersion: mod.LatestFileVersion?.ToString(), url: mod.Url);
             }
             catch (Exception ex)
             {
-                return new ModInfoModel(ex.ToString());
+                return new ModInfoModel().SetError(RemoteModStatus.TemporaryError, ex.ToString());
             }
         }
 
diff --git a/src/SMAPI.Web/Framework/ModRepositories/RemoteModStatus.cs b/src/SMAPI.Web/Framework/ModRepositories/RemoteModStatus.cs
new file mode 100644
index 00000000..02876556
--- /dev/null
+++ b/src/SMAPI.Web/Framework/ModRepositories/RemoteModStatus.cs
@@ -0,0 +1,18 @@
+namespace StardewModdingAPI.Web.Framework.ModRepositories
+{
+    /// <summary>The mod availability status on a remote site.</summary>
+    internal enum RemoteModStatus
+    {
+        /// <summary>The mod is valid.</summary>
+        Ok,
+
+        /// <summary>The mod data was fetched, but the data is not valid (e.g. version isn't semantic).</summary>
+        InvalidData,
+
+        /// <summary>The mod does not exist.</summary>
+        DoesNotExist,
+
+        /// <summary>The mod was temporarily unavailable (e.g. the site could not be reached or an unknown error occurred).</summary>
+        TemporaryError
+    }
+}