diff --git a/libdiscover/backends/SnapBackend/SnapBackend.cpp b/libdiscover/backends/SnapBackend/SnapBackend.cpp
index f8f7338f..896069a6 100644
--- a/libdiscover/backends/SnapBackend/SnapBackend.cpp
+++ b/libdiscover/backends/SnapBackend/SnapBackend.cpp
@@ -1,182 +1,184 @@
 /***************************************************************************
  *   Copyright © 2013 Aleix Pol Gonzalez <aleixpol@blue-systems.com>       *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or         *
  *   modify it under the terms of the GNU General Public License as        *
  *   published by the Free Software Foundation; either version 2 of        *
  *   the License or (at your option) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "SnapBackend.h"
 #include "SnapTransaction.h"
 #include "SnapResource.h"
 #include "SnapReviewsBackend.h"
 #include <resources/StandardBackendUpdater.h>
 #include <resources/SourcesModel.h>
 #include <Category/Category.h>
 #include <Transaction/Transaction.h>
 #include <resources/StoredResultsStream.h>
 
 #include <KAboutData>
 #include <KLocalizedString>
 #include <KPluginFactory>
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <QDebug>
 #include <QThread>
 #include <QTimer>
 #include <QAction>
 
 #include "utils.h"
 
 DISCOVER_BACKEND_PLUGIN(SnapBackend)
 
 SnapBackend::SnapBackend(QObject* parent)
     : AbstractResourcesBackend(parent)
     , m_updater(new StandardBackendUpdater(this))
     , m_reviews(new SnapReviewsBackend(this))
 {
     connect(m_reviews, &SnapReviewsBackend::ratingsReady, this, &AbstractResourcesBackend::emitRatingsReady);
 
     //make sure we populate the installed resources first
     refreshStates();
 
     SourcesModel::global()->addBackend(this);
 }
 
 int SnapBackend::updatesCount() const
 {
     return m_updater->updatesCount();
 }
 
 static ResultsStream* voidStream() { return new ResultsStream(QStringLiteral("Snap-void"), {}); }
 
 ResultsStream * SnapBackend::search(const AbstractResourcesBackend::Filters& filters)
 {
     if (!filters.extends.isEmpty()) {
         return voidStream();
     } else if (!filters.resourceUrl.isEmpty()) {
         return findResourceByPackageName(filters.resourceUrl);
     } else if (filters.category && filters.category->isAddons()) {
         return voidStream();
     } else if (filters.state >= AbstractResource::Installed) {
         return populate(m_client.getSnaps());
     } else if (!filters.search.isEmpty()) {
         return populate(m_client.find(QSnapdClient::FindFlag::None, filters.search));
     }
     return voidStream();
 }
 
 ResultsStream * SnapBackend::findResourceByPackageName(const QUrl& search)
 {
-    return search.scheme() == QLatin1String("snap") ? populate(m_client.find(QSnapdClient::MatchName, search.host())) : voidStream();
+    return search.scheme() == QLatin1String("snap") ? populate(m_client.find(QSnapdClient::MatchName, search.host())) :
+           search.scheme() == QLatin1String("appstream") ? new ResultsStream(QLatin1String("snap-appstreamurl"), kFilter<QVector<AbstractResource*>>(m_resources, [search](SnapResource* res){ return res->appstreamId() == search.host(); } )) :
+                voidStream();
 }
 
 template <class T>
 ResultsStream* SnapBackend::populate(T* job)
 {
     auto stream = new ResultsStream(QStringLiteral("Snap-populate"));
 
     connect(job, &QSnapdFindRequest::complete, stream, [stream, this, job]() {
         if (job->error()) {
             qDebug() << "error:" << job->error() << job->errorString();
             stream->finish();
             return;
         }
 
         QVector<AbstractResource*> ret;
         QSet<SnapResource*> resources;
         resources.reserve(job->snapCount());
         for (int i=0, c=job->snapCount(); i<c; ++i) {
             QSharedPointer<QSnapdSnap> snap(job->snap(i));
             const auto snapname = snap->name();
             SnapResource* res = m_resources.value(snapname);
             if (!res) {
                 res = new SnapResource(snap, AbstractResource::None, this);
                 Q_ASSERT(res->packageName() == snapname);
                 resources += res;
             } else {
                 res->setSnap(snap);
             }
             ret += res;
         }
 
         foreach(SnapResource* res, resources)
             m_resources[res->packageName()] = res;
 
         if (!ret.isEmpty())
             stream->resourcesFound(ret);
         stream->finish();
     });
     job->runAsync();
     return stream;
 }
 
 void SnapBackend::setFetching(bool fetching)
 {
     if (m_fetching != fetching) {
         m_fetching = fetching;
         Q_EMIT fetchingChanged();
     } else {
         qWarning() << "fetching already on state" << fetching;
     }
 }
 
 AbstractBackendUpdater* SnapBackend::backendUpdater() const
 {
     return m_updater;
 }
 
 AbstractReviewsBackend* SnapBackend::reviewsBackend() const
 {
     return m_reviews;
 }
 
 Transaction* SnapBackend::installApplication(AbstractResource* app, const AddonList& addons)
 {
     Q_ASSERT(addons.isEmpty());
     return installApplication(app);
 }
 
 Transaction* SnapBackend::installApplication(AbstractResource* _app)
 {
     auto app = qobject_cast<SnapResource*>(_app);
 	return new SnapTransaction(&m_client, app, Transaction::InstallRole, AbstractResource::Installed);
 }
 
 Transaction* SnapBackend::removeApplication(AbstractResource* _app)
 {
     auto app = qobject_cast<SnapResource*>(_app);
 	return new SnapTransaction(&m_client, app, Transaction::RemoveRole, AbstractResource::None);
 }
 
 QString SnapBackend::displayName() const
 {
     return QStringLiteral("Snap");
 }
 
 void SnapBackend::refreshStates()
 {
     auto ret = new StoredResultsStream({populate(m_client.list())});
     connect(ret, &StoredResultsStream::finished, this, [this, ret](){
         for (auto res: m_resources) {
             if (ret->resources().contains(res))
                 res->setState(AbstractResource::Installed);
             else
                 res->setState(AbstractResource::None);
         }
     });
 }
 
 #include "SnapBackend.moc"
diff --git a/libdiscover/backends/SnapBackend/SnapResource.cpp b/libdiscover/backends/SnapBackend/SnapResource.cpp
index 209c8253..d9095473 100644
--- a/libdiscover/backends/SnapBackend/SnapResource.cpp
+++ b/libdiscover/backends/SnapBackend/SnapResource.cpp
@@ -1,328 +1,328 @@
 /***************************************************************************
  *   Copyright © 2013 Aleix Pol Gonzalez <aleixpol@blue-systems.com>       *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or         *
  *   modify it under the terms of the GNU General Public License as        *
  *   published by the Free Software Foundation; either version 2 of        *
  *   the License or (at your option) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #include "SnapResource.h"
 #include "SnapBackend.h"
 #include <QDebug>
 #include <QProcess>
 #include <QBuffer>
 #include <QImageReader>
 #include <QStandardItemModel>
 #include <KLocalizedString>
 #include <utils.h>
 #include <QProcess>
 
 QDebug operator<<(QDebug debug, const QSnapdPlug& plug)
 {
     QDebugStateSaver saver(debug);
     debug.nospace() << "QSnapdPlug(";
     debug.nospace() << "name:" << plug.name() << ',';
     debug.nospace() << "snap:" << plug.snap() << ',';
     debug.nospace() << "label:" << plug.label() << ',';
     debug.nospace() << "interface:" << plug.interface() << ',';
     debug.nospace() << "connectionCount:" << plug.connectionCount();
     debug.nospace() << ')';
     return debug;
 }
 
 QDebug operator<<(QDebug debug, const QSnapdSlot& slot)
 {
     QDebugStateSaver saver(debug);
     debug.nospace() << "QSnapdSlot(";
     debug.nospace() << "name:" << slot.name() << ',';
     debug.nospace() << "label:" << slot.label() << ',';
     debug.nospace() << "snap:" << slot.snap() << ',';
     debug.nospace() << "interface:" << slot.interface() << ',';
     debug.nospace() << "connectionCount:" << slot.connectionCount();
     debug.nospace() << ')';
     return debug;
 }
 
 QDebug operator<<(QDebug debug, const QSnapdPlug* plug)
 {
     QDebugStateSaver saver(debug);
     debug.nospace() << "*" << *plug;
     return debug;
 }
 
 QDebug operator<<(QDebug debug, const QSnapdSlot* slot)
 {
     QDebugStateSaver saver(debug);
     debug.nospace() << "*" << *slot;
     return debug;
 }
 
 const QStringList SnapResource::m_objects({ QStringLiteral("qrc:/snapui/PermissionsButton.qml") });
 
 SnapResource::SnapResource(QSharedPointer<QSnapdSnap> snap, AbstractResource::State state, SnapBackend* backend)
     : AbstractResource(backend)
     , m_state(state)
     , m_snap(snap)
 {
     setObjectName(snap->name());
 }
 
 QString SnapResource::availableVersion() const
 {
     return installedVersion();
 }
 
 QStringList SnapResource::categories()
 {
     return { QStringLiteral("Application") };
 }
 
 QString SnapResource::comment()
 {
     return m_snap->summary();
 }
 
 int SnapResource::size()
 {
 //     return isInstalled() ? m_snap->installedSize() : m_snap->downloadSize();
     return m_snap->downloadSize();
 }
 
 QVariant SnapResource::icon() const
 {
     if (m_icon.isNull()) {
         m_icon = [this]() -> QVariant {
             const auto iconPath = m_snap->icon();
             if (iconPath.isEmpty())
                 return QStringLiteral("package-x-generic");
 
             if (!iconPath.startsWith(QLatin1Char('/')))
                 return QUrl(iconPath);
 
             auto backend = qobject_cast<SnapBackend*>(parent());
             auto req = backend->client()->getIcon(packageName());
             connect(req, &QSnapdGetIconRequest::complete, this, &SnapResource::gotIcon);
             req->runAsync();
             return {};
         }();
     }
     return m_icon;
 }
 
 void SnapResource::gotIcon()
 {
     auto req = qobject_cast<QSnapdGetIconRequest*>(sender());
     if (req->error()) {
         qWarning() << "icon error" << req->errorString();
         return;
     }
 
     auto icon = req->icon();
 
     QBuffer buffer;
     buffer.setData(icon->data());
     QImageReader reader(&buffer);
 
     auto theIcon = QVariant::fromValue<QImage>(reader.read());
     if (theIcon != m_icon) {
         m_icon = theIcon;
         iconChanged();
     }
 }
 
 QString SnapResource::installedVersion() const
 {
     return m_snap->version();
 }
 
 QString SnapResource::license()
 {
     return m_snap->license();
 }
 
 QString SnapResource::longDescription()
 {
     return m_snap->description();
 }
 
 QString SnapResource::name() const
 {
     return m_snap->title().isEmpty() ? m_snap->name() : m_snap->title();
 }
 
 QString SnapResource::origin() const
 {
     return QStringLiteral("snappy:") + m_snap->channel();
 }
 
 QString SnapResource::packageName() const
 {
     return m_snap->name();
 }
 
 QString SnapResource::section()
 {
     return QStringLiteral("snap");
 }
 
 AbstractResource::State SnapResource::state()
 {
     return m_state;
 }
 
 void SnapResource::setState(AbstractResource::State state)
 {
     if (m_state != state) {
         m_state = state;
         Q_EMIT stateChanged();
     }
 }
 
 void SnapResource::fetchChangelog()
 {
     QString log;
     emit changelogFetched(log);
 }
 
 void SnapResource::fetchScreenshots()
 {
     QList<QUrl> screenshots;
     for(int i = 0, c = m_snap->screenshotCount(); i<c; ++i) {
         QScopedPointer<QSnapdScreenshot> screenshot(m_snap->screenshot(i));
         screenshots << QUrl(screenshot->url());
     }
     Q_EMIT screenshotsFetched(screenshots, screenshots);
 }
 
 void SnapResource::invokeApplication() const
 {
     QProcess::startDetached(QStringLiteral("snap"), {QStringLiteral("run"), packageName()});
 }
 
 bool SnapResource::isTechnical() const
 {
     return m_snap->snapType() != QLatin1String("app");
 }
 
-QUrl SnapResource::url() const
-{
-    //FIXME interim, until it has an appstreamId
-    return QUrl(QStringLiteral("snap://") + packageName());
-}
-
 void SnapResource::setSnap(const QSharedPointer<QSnapdSnap>& snap)
 {
     Q_ASSERT(snap->name() == m_snap->name());
     if (m_snap == snap)
         return;
 
     const bool newSize = m_snap->installedSize() != snap->installedSize() || m_snap->downloadSize() != snap->downloadSize();
     m_snap = snap;
     if (newSize)
         Q_EMIT sizeChanged();
 }
 
 QDate SnapResource::releaseDate() const
 {
     return {};
 }
 
 class PlugsModel : public QStandardItemModel
 {
 public:
     enum Roles {
         PlugNameRole = Qt::UserRole + 1,
         SlotSnapRole,
         SlotNameRole
     };
 
     PlugsModel(QSnapdSnap* snap, SnapBackend* backend, QObject* parent)
         : QStandardItemModel(parent)
         , m_snap(snap)
         , m_backend(backend)
     {
         setItemRoleNames(roleNames().unite(
             { {Qt::CheckStateRole, "checked"} }
         ));
 
         auto req = backend->client()->getInterfaces();
         req->runSync();
 
         QHash<QString, QVector<QSnapdSlot*>> slotsForInterface;
         for (int i = 0; i<req->slotCount(); ++i) {
             const auto slot = req->slot(i);
             slot->setParent(this);
             slotsForInterface[slot->interface()].append(slot);
 
         }
 
         for (int i = 0; i<req->plugCount(); ++i) {
             const QScopedPointer<QSnapdPlug> plug(req->plug(i));
             if (plug->snap() == m_snap->name()) {
                 for (auto slot: slotsForInterface[plug->interface()]) {
                     auto item = new QStandardItem;
                     if (plug->label().isEmpty())
                         item->setText(plug->name());
                     else
                         item->setText(i18n("%1 - %2", plug->name(), plug->label()));
 
                     item->setCheckable(true);
                     item->setCheckState(plug->connectionCount()>0 ? Qt::Checked : Qt::Unchecked);
                     item->setData(plug->name(), PlugNameRole);
                     item->setData(slot->snap(), SlotSnapRole);
                     item->setData(slot->name(), SlotNameRole);
                     appendRow(item);
                 }
             }
         }
     }
 
 private:
     bool setData(const QModelIndex & index, const QVariant & value, int role) override {
         if (role != Qt::CheckStateRole)
             return QStandardItemModel::setData(index, value, role);
 
         auto item = itemFromIndex(index);
         Q_ASSERT(item);
         const QString plugName = item->data(PlugNameRole).toString();
         const QString slotSnap = item->data(SlotSnapRole).toString();
         const QString slotName = item->data(SlotNameRole).toString();
 
         QSnapdRequest* req;
 
         if (item->checkState() == Qt::Checked) {
             req = m_backend->client()->connectInterface(m_snap->name(), plugName, slotSnap, slotName);
         } else {
             req = m_backend->client()->disconnectInterface(m_snap->name(), plugName, slotSnap, slotName);
         }
         req->runSync();
         if (req->error()) {
             qWarning() << "snapd error" << req->errorString();
         }
         return req->error() == QSnapdRequest::NoError;
     }
 
     QSnapdSnap* const m_snap;
     SnapBackend* const m_backend;
 };
 
 QAbstractItemModel* SnapResource::plugs(QObject* p)
 {
     if (!isInstalled())
         return new QStandardItemModel(p);
 
 
     return new PlugsModel(m_snap.data(), qobject_cast<SnapBackend*>(parent()), p);
 }
+
+QString SnapResource::appstreamId() const
+{
+    const auto ids = m_snap->commonIds();
+    return ids.isEmpty() ? QLatin1String("com.snap.") + m_snap->name() : ids.first();
+}
diff --git a/libdiscover/backends/SnapBackend/SnapResource.h b/libdiscover/backends/SnapBackend/SnapResource.h
index fc47b08f..481f5804 100644
--- a/libdiscover/backends/SnapBackend/SnapResource.h
+++ b/libdiscover/backends/SnapBackend/SnapResource.h
@@ -1,78 +1,78 @@
 /***************************************************************************
  *   Copyright © 2013 Aleix Pol Gonzalez <aleixpol@blue-systems.com>       *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or         *
  *   modify it under the terms of the GNU General Public License as        *
  *   published by the Free Software Foundation; either version 2 of        *
  *   the License or (at your option) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifndef SNAPRESOURCE_H
 #define SNAPRESOURCE_H
 
 #include <resources/AbstractResource.h>
 #include <QJsonObject>
 #include <Snapd/Snap>
 #include <QSharedPointer>
 
 class SnapBackend;
 class QAbstractItemModel;
 
 class SnapResource : public AbstractResource
 {
 Q_OBJECT
 Q_PROPERTY(QStringList objects MEMBER m_objects CONSTANT)
 public:
     explicit SnapResource(QSharedPointer<QSnapdSnap> snap, AbstractResource::State state, SnapBackend* parent);
     ~SnapResource() override = default;
 
     QString section() override;
     QString origin() const override;
     QString longDescription() override;
     QString availableVersion() const override;
     QString installedVersion() const override;
     QString license() override;
     int size() override;
     QStringList categories() override;
     AbstractResource::State state() override;
     QVariant icon() const override;
     QString comment() override;
     QString name() const override;
     QString packageName() const override;
     bool isTechnical() const override;
     bool canExecute() const override { return true; }
     void invokeApplication() const override;
     void fetchChangelog() override;
     void fetchScreenshots() override;
     QList<PackageState> addonsInformation() override { return {}; }
-    QUrl url() const override;
     void setSnap(const QSharedPointer<QSnapdSnap> &snap);
 
     void setState(AbstractResource::State state);
     QString sourceIcon() const override { return QStringLiteral("snap"); }
 
     QDate releaseDate() const override;
 
     Q_SCRIPTABLE QAbstractItemModel* plugs(QObject* parents);
+    QString appstreamId() const override;
 
 public:
     void gotIcon();
     AbstractResource::State m_state;
 
     QSharedPointer<QSnapdSnap> m_snap;
     mutable QVariant m_icon;
     static const QStringList m_objects;
 };
 
 #endif // SNAPRESOURCE_H