diff --git a/contentcuration/contentcuration/frontend/channelEdit/views/ImportFromChannels/BrowsingCard.vue b/contentcuration/contentcuration/frontend/channelEdit/views/ImportFromChannels/BrowsingCard.vue
index a8a92087cd..9a9621f8f5 100644
--- a/contentcuration/contentcuration/frontend/channelEdit/views/ImportFromChannels/BrowsingCard.vue
+++ b/contentcuration/contentcuration/frontend/channelEdit/views/ImportFromChannels/BrowsingCard.vue
@@ -149,7 +149,7 @@
         if (this.isTopic) {
           return `${baseUrl}#/${this.node.id}`;
         }
-        return `${baseUrl}#/${this.node.parent_id}/${this.node.id}`;
+        return `${baseUrl}#/${this.node.parent}/${this.node.id}`;
       },
       resourcesMsg() {
         let count;
diff --git a/contentcuration/contentcuration/frontend/channelEdit/views/ImportFromChannels/ImportFromChannelsModal.vue b/contentcuration/contentcuration/frontend/channelEdit/views/ImportFromChannels/ImportFromChannelsModal.vue
index e3e394602d..60423ee33b 100644
--- a/contentcuration/contentcuration/frontend/channelEdit/views/ImportFromChannels/ImportFromChannelsModal.vue
+++ b/contentcuration/contentcuration/frontend/channelEdit/views/ImportFromChannels/ImportFromChannelsModal.vue
@@ -74,7 +74,7 @@
 
 <script>
 
-  import { mapActions, mapMutations, mapState } from 'vuex';
+  import { mapActions, mapMutations, mapState, mapGetters } from 'vuex';
   import sumBy from 'lodash/sumBy';
   import { RouteNames } from '../../constants';
   import ResourceDrawer from '../../components/ResourceDrawer';
@@ -114,6 +114,7 @@
     },
     computed: {
       ...mapState('importFromChannels', ['selected']),
+      ...mapGetters('contentNode', ['getContentNode']),
       dialog: {
         get() {
           return IMPORT_ROUTES.includes(this.$route.name);
@@ -210,9 +211,12 @@
       },
       handleClickImport() {
         const nodeIds = this.selected.map(({ id }) => id);
+        // Grab the source nodes from Vuex, since search should have loaded them into it
+        const sourceNodes = nodeIds.map(id => this.getContentNode(id));
         return this.copyContentNodes({
           id__in: nodeIds,
           target: this.$route.params.destNodeId,
+          sourceNodes,
         }).then(() => {
           // When exiting, do not show snackbar when clearing selections
           this.showSnackbar = false;
diff --git a/contentcuration/contentcuration/frontend/channelEdit/vuex/contentNode/actions.js b/contentcuration/contentcuration/frontend/channelEdit/vuex/contentNode/actions.js
index d0c3f2bba1..89eba97c59 100644
--- a/contentcuration/contentcuration/frontend/channelEdit/vuex/contentNode/actions.js
+++ b/contentcuration/contentcuration/frontend/channelEdit/vuex/contentNode/actions.js
@@ -391,11 +391,17 @@ export function deleteContentNodes(context, contentNodeIds) {
 
 export function copyContentNode(
   context,
-  { id, target, position = RELATIVE_TREE_POSITIONS.LAST_CHILD, excluded_descendants = null } = {}
+  {
+    id,
+    target,
+    position = RELATIVE_TREE_POSITIONS.LAST_CHILD,
+    excluded_descendants = null,
+    sourceNode = null,
+  } = {}
 ) {
   // First, this will parse the tree and create the copy the local tree nodes,
   // with a `source_id` of the source node then create the content node copies
-  return ContentNode.copy(id, target, position, excluded_descendants).then(node => {
+  return ContentNode.copy(id, target, position, excluded_descendants, sourceNode).then(node => {
     context.commit('ADD_CONTENTNODE', node);
     return node;
   });
@@ -403,10 +409,16 @@ export function copyContentNode(
 
 export function copyContentNodes(
   context,
-  { id__in, target, position = RELATIVE_TREE_POSITIONS.LAST_CHILD }
+  { id__in, target, position = RELATIVE_TREE_POSITIONS.LAST_CHILD, sourceNodes = null }
 ) {
   return Promise.all(
-    id__in.map(id => context.dispatch('copyContentNode', { id, target, position }))
+    id__in.map(id => {
+      let sourceNode = null;
+      if (sourceNodes) {
+        sourceNode = sourceNodes.find(n => n.id === id);
+      }
+      return context.dispatch('copyContentNode', { id, target, position, sourceNode });
+    })
   );
 }
 
diff --git a/contentcuration/contentcuration/frontend/channelEdit/vuex/contentNode/utils.js b/contentcuration/contentcuration/frontend/channelEdit/vuex/contentNode/utils.js
index f7642556b0..634e17b75a 100644
--- a/contentcuration/contentcuration/frontend/channelEdit/vuex/contentNode/utils.js
+++ b/contentcuration/contentcuration/frontend/channelEdit/vuex/contentNode/utils.js
@@ -1,9 +1,12 @@
+import isString from 'lodash/isString';
 import find from 'lodash/find';
 import { ContentKindsNames } from 'shared/leUtils/ContentKinds';
 import { RolesNames } from 'shared/leUtils/Roles';
 
 export function parseNode(node, children) {
-  const thumbnail_encoding = JSON.parse(node.thumbnail_encoding || '{}');
+  const thumbnail_encoding = isString(node.thumbnail_encoding)
+    ? JSON.parse(node.thumbnail_encoding || '{}')
+    : node.thumbnail_encoding || {};
   const tags = Object.keys(node.tags || {});
   const aggregateValues = {};
   if (node.kind === ContentKindsNames.TOPIC) {
diff --git a/contentcuration/contentcuration/frontend/channelEdit/vuex/importFromChannels/actions.js b/contentcuration/contentcuration/frontend/channelEdit/vuex/importFromChannels/actions.js
index 5f2bc585e3..3cb9a1d0b3 100644
--- a/contentcuration/contentcuration/frontend/channelEdit/vuex/importFromChannels/actions.js
+++ b/contentcuration/contentcuration/frontend/channelEdit/vuex/importFromChannels/actions.js
@@ -1,17 +1,54 @@
+import partition from 'lodash/partition';
 import client from 'shared/client';
+import urls from 'shared/urls';
+import * as publicApi from 'shared/data/public';
 import { NOVALUE, ChannelListTypes } from 'shared/constants';
 
 import { Channel, SavedSearch } from 'shared/data/resources';
 
-export function fetchResourceSearchResults(context, params) {
+export async function fetchResourceSearchResults(context, params) {
   params = { ...params };
   delete params['last'];
   params.page_size = params.page_size || 25;
   params.channel_list = params.channel_list || ChannelListTypes.PUBLIC;
-  return client.get(window.Urls.search_list(), { params }).then(response => {
-    context.commit('contentNode/ADD_CONTENTNODES', response.data.results, { root: true });
-    return response.data;
-  });
+
+  const response = await client.get(urls.search_list(), { params });
+
+  // Split nodes into public and private so we can call the separate apis
+  const [publicNodes, privateNodes] = partition(response.data.results, node => node.public);
+
+  const privatePromise = privateNodes.length
+    ? context.dispatch(
+        'contentNode/loadContentNodes',
+        {
+          id__in: privateNodes.map(node => node.id),
+        },
+        { root: true }
+      )
+    : Promise.resolve([]);
+
+  await Promise.all([
+    // the loadContentNodes action already loads the nodes into vuex
+    privatePromise,
+    Promise.all(
+      // The public API is cached, so we can hopefully call it multiple times without
+      // worrying too much about performance
+      publicNodes.map(async node => {
+        const publicNode = await publicApi.getContentNode(node.node_id).catch(() => null);
+        if (!publicNode) {
+          return;
+        }
+        return publicApi.convertContentNodeResponse(node.id, node.root_id, publicNode);
+      })
+    )
+      .then(nodes => nodes.filter(Boolean))
+      .then(nodes => {
+        context.commit('contentNode/ADD_CONTENTNODES', nodes, { root: true });
+        return nodes;
+      }),
+  ]);
+
+  return response.data;
 }
 
 export function loadChannels(context, params) {
diff --git a/contentcuration/contentcuration/frontend/shared/data/__tests__/ContentNodeResource.spec.js b/contentcuration/contentcuration/frontend/shared/data/__tests__/ContentNodeResource.spec.js
index eaa3249413..a7f58f81c2 100644
--- a/contentcuration/contentcuration/frontend/shared/data/__tests__/ContentNodeResource.spec.js
+++ b/contentcuration/contentcuration/frontend/shared/data/__tests__/ContentNodeResource.spec.js
@@ -298,7 +298,10 @@ describe('ContentNode methods', () => {
     it('should reject with error when attempting to set as child of itself', async () => {
       parent.id = 'abc123';
       await expect(
-        ContentNode.resolveTreeInsert('abc123', 'target', 'position', false, jest.fn())
+        ContentNode.resolveTreeInsert(
+          { id: 'abc123', target: 'target', position: 'position', isCreate: false },
+          jest.fn()
+        )
       ).rejects.toThrow('Cannot set node as child of itself');
       expect(resolveParent).toHaveBeenCalledWith('target', 'position');
     });
@@ -307,7 +310,10 @@ describe('ContentNode methods', () => {
       it('should default to appending', async () => {
         const cb = jest.fn(() => Promise.resolve('results'));
         await expect(
-          ContentNode.resolveTreeInsert('abc123', 'target', 'position', false, cb)
+          ContentNode.resolveTreeInsert(
+            { id: 'abc123', target: 'target', position: 'position', isCreate: false },
+            cb
+          )
         ).resolves.toEqual('results');
         expect(resolveParent).toHaveBeenCalledWith('target', 'position');
         expect(treeLock).toHaveBeenCalledWith(parent.root_id, expect.any(Function));
@@ -340,7 +346,10 @@ describe('ContentNode methods', () => {
         const cb = jest.fn(() => Promise.resolve('results'));
         parent.channel_id = null;
         await expect(
-          ContentNode.resolveTreeInsert('abc123', 'target', 'position', false, cb)
+          ContentNode.resolveTreeInsert(
+            { id: 'abc123', target: 'target', position: 'position', isCreate: false },
+            cb
+          )
         ).resolves.toEqual('results');
         expect(resolveParent).toHaveBeenCalledWith('target', 'position');
         expect(treeLock).toHaveBeenCalledWith(parent.root_id, expect.any(Function));
@@ -377,7 +386,10 @@ describe('ContentNode methods', () => {
           .map((_, i) => ({ id: uuid4(), lft: i, title: `Sibling ${i}` }));
 
         await expect(
-          ContentNode.resolveTreeInsert('abc123', 'target', 'position', false, cb)
+          ContentNode.resolveTreeInsert(
+            { id: 'abc123', target: 'target', position: 'position', isCreate: false },
+            cb
+          )
         ).resolves.toEqual('results');
         expect(resolveParent).toHaveBeenCalledWith('target', 'position');
         expect(treeLock).toHaveBeenCalledWith(parent.root_id, expect.any(Function));
@@ -413,7 +425,10 @@ describe('ContentNode methods', () => {
           .fill(1)
           .map((_, i) => ({ id: uuid4(), title: `Sibling ${i}` }));
         await expect(
-          ContentNode.resolveTreeInsert('abc123', 'target', 'position', false, cb)
+          ContentNode.resolveTreeInsert(
+            { id: 'abc123', target: 'target', position: 'position', isCreate: false },
+            cb
+          )
         ).rejects.toThrow('New lft value evaluated to null');
         expect(resolveParent).toHaveBeenCalledWith('target', 'position');
         expect(treeLock).toHaveBeenCalledWith(parent.root_id, expect.any(Function));
@@ -428,7 +443,10 @@ describe('ContentNode methods', () => {
       it('should default to appending', async () => {
         const cb = jest.fn(() => Promise.resolve('results'));
         await expect(
-          ContentNode.resolveTreeInsert('abc123', 'target', 'position', true, cb)
+          ContentNode.resolveTreeInsert(
+            { id: 'abc123', target: 'target', position: 'position', isCreate: true },
+            cb
+          )
         ).resolves.toEqual('results');
         expect(resolveParent).toHaveBeenCalledWith('target', 'position');
         expect(treeLock).toHaveBeenCalledWith(parent.root_id, expect.any(Function));
@@ -465,7 +483,10 @@ describe('ContentNode methods', () => {
           .fill(1)
           .map((_, i) => ({ id: uuid4(), title: `Sibling ${i}` }));
         await expect(
-          ContentNode.resolveTreeInsert('abc123', 'target', 'position', true, cb)
+          ContentNode.resolveTreeInsert(
+            { id: 'abc123', target: 'target', position: 'position', isCreate: true },
+            cb
+          )
         ).resolves.toEqual('results');
         expect(resolveParent).toHaveBeenCalledWith('target', 'position');
         expect(treeLock).toHaveBeenCalledWith(parent.root_id, expect.any(Function));
@@ -502,7 +523,10 @@ describe('ContentNode methods', () => {
           .fill(1)
           .map((_, i) => ({ id: uuid4(), title: `Sibling ${i}` }));
         await expect(
-          ContentNode.resolveTreeInsert('abc123', 'target', 'position', true, cb)
+          ContentNode.resolveTreeInsert(
+            { id: 'abc123', target: 'target', position: 'position', isCreate: true },
+            cb
+          )
         ).rejects.toThrow('New lft value evaluated to null');
         expect(resolveParent).toHaveBeenCalledWith('target', 'position');
         expect(treeLock).toHaveBeenCalledWith(parent.root_id, expect.any(Function));
diff --git a/contentcuration/contentcuration/frontend/shared/data/applyRemoteChanges.js b/contentcuration/contentcuration/frontend/shared/data/applyRemoteChanges.js
index 02b34ca9af..ea10bc6768 100644
--- a/contentcuration/contentcuration/frontend/shared/data/applyRemoteChanges.js
+++ b/contentcuration/contentcuration/frontend/shared/data/applyRemoteChanges.js
@@ -82,7 +82,7 @@ function applyMove(change) {
   }
 
   const { key, target, position } = change;
-  return resource.resolveTreeInsert(key, target, position, false, data => {
+  return resource.resolveTreeInsert({ id: key, target, position, isCreate: false }, data => {
     return transaction(change, () => {
       return resource.tableMove(data);
     });
@@ -97,7 +97,7 @@ function applyCopy(change) {
 
   const { key, target, position, from_key } = change;
   // copying takes the ID of the node to copy, so we use `from_key`
-  return resource.resolveTreeInsert(from_key, target, position, true, data => {
+  return resource.resolveTreeInsert({ id: from_key, target, position, isCreate: true }, data => {
     return transaction(change, () => {
       // Update the ID on the payload to match the received change, since isCreate=true
       // would generate new IDs
diff --git a/contentcuration/contentcuration/frontend/shared/data/public.js b/contentcuration/contentcuration/frontend/shared/data/public.js
new file mode 100644
index 0000000000..644fb138a8
--- /dev/null
+++ b/contentcuration/contentcuration/frontend/shared/data/public.js
@@ -0,0 +1,190 @@
+/**
+ * Utilities related to Kolibri Public API
+ *
+ * We don't need to put requests to these APIs behind Vuex or IndexedDB caching because the APIs are
+ * already cached by cloudflare and by extension, the browser too.
+ * Let the browser do the caching for us.
+ *
+ * See bottom of file for '@typedef's
+ */
+import isFunction from 'lodash/isFunction';
+import { RolesNames } from 'shared/leUtils/Roles';
+import { findLicense } from 'shared/utils/helpers';
+import { ContentKindsNames } from 'shared/leUtils/ContentKinds';
+import client from 'shared/client';
+import urls from 'shared/urls';
+
+/**
+ * Assumes obj[key] is an array of strings
+ * @param {string} key
+ * @param {object} obj
+ * @return {object}
+ * @private
+ */
+function _convertMetadataLabel(key, obj) {
+  const converted = {};
+  for (const labelKey of obj[key]) {
+    converted[labelKey] = true;
+  }
+  return converted;
+}
+
+const CONTENT_NODE_FIELD_MAP = {
+  // `destination field`: `source field` or value producing function
+  node_id: 'id',
+  content_id: 'content_id',
+  channel_id: 'channel_id',
+  parent: 'parent',
+  title: 'title',
+  description: 'description',
+  kind: 'kind',
+  author: 'author',
+  provider: 'provider',
+  aggregator: 'aggregator',
+  suggested_duration: 'duration',
+  lft: 'lft',
+  changed: () => false,
+  published: () => true,
+  complete: () => true,
+  has_updated_descendants: () => false,
+  has_new_descendants: () => false,
+  learning_activities: _convertMetadataLabel.bind({}, 'learning_activities'),
+  grade_levels: _convertMetadataLabel.bind({}, 'grade_levels'),
+  accessibility_labels: _convertMetadataLabel.bind({}, 'accessibility_labels'),
+  categories: _convertMetadataLabel.bind({}, 'categories'),
+  resource_types: _convertMetadataLabel.bind({}, 'resource_types'),
+  tags: _convertMetadataLabel.bind({}, 'tags'),
+  extra_fields: obj => ({ options: JSON.parse(obj['options']) }),
+  role_visibility: obj => (obj['coach_content'] ? RolesNames.COACH : RolesNames.LEARNER),
+  license: obj => findLicense(obj['license_name']),
+  license_description: 'license_description',
+  copyright_holder: 'license_owner',
+  coach_count: 'num_coach_contents',
+  // see MPTTModel for explanation of this calculation
+  total_count: obj =>
+    obj['kind'] === ContentKindsNames.TOPIC ? (obj['rght'] - obj['lft'] - 1) / 2 : 1,
+  language: obj => obj['lang']['id'],
+  thumbnail_src: obj => new URL(obj['thumbnail'], window.location.origin).pathname,
+  thumbnail_encoding: () => '{}',
+
+  // unavailable in public API
+  // 'resource_count': 'num_resources',
+  // 'root_id': 'root_id',
+};
+
+/**
+ * Convert a content node from the public API into a content node for the Studio frontend
+ * @param {string} id - the actual ID of the node on Studio's side
+ * @param {string} root_id - the root content node ID
+ * @param {PublicContentNode} publicNode
+ * @return {Promise<{id}>}
+ */
+export async function convertContentNodeResponse(id, root_id, publicNode) {
+  const contentNode = {
+    // the public API does not return the actual id, but 'node_id' as the id, so this requires
+    // us to know what the actual id is
+    id,
+    // The public API returns the channel ID as the root_id
+    root_id,
+  };
+
+  // Convert the response node into a content node
+  for (const [key, fieldMapper] of Object.entries(CONTENT_NODE_FIELD_MAP)) {
+    if (isFunction(fieldMapper)) {
+      contentNode[key] = fieldMapper(publicNode);
+    } else {
+      contentNode[key] = publicNode[fieldMapper];
+    }
+  }
+
+  // If the parent is the channel, then set the parent to the root_id
+  if (contentNode.parent === contentNode.channel_id) {
+    contentNode.parent = root_id;
+  }
+  return contentNode;
+}
+
+/**
+ * Get a channel from the public API
+ * @param {String} channelId
+ * @return {Promise<PublicChannelMetadata>}
+ */
+export function getChannel(channelId) {
+  return client.get(urls.publicchannel_detail(channelId)).then(response => response.data);
+}
+
+/**
+ * Get a content node from the public API
+ * @param {String} nodeId
+ * @return {Promise<PublicContentNode>}
+ */
+export function getContentNode(nodeId) {
+  return client.get(urls.publiccontentnode_detail(nodeId)).then(response => response.data);
+}
+
+/**
+ * @typedef {Object} PublicFile
+ * @property {string} id
+ * @property {string} contentnode
+ * @property {string} preset
+ * @property {string} lang
+ * @property {boolean} supplementary
+ * @property {boolean} thumbnail
+ * @property {number} priority
+ * @property {number} file_size
+ * @property {string} checksum
+ * @property {string} extension
+ */
+
+/**
+ * @typedef {Object} PublicContentNode
+ * @property {string} id
+ * @property {string} content_id
+ * @property {string} channel_id
+ * @property {string} parent
+ * @property {string} title
+ * @property {string} description
+ * @property {string} kind
+ * @property {string} author
+ * @property {string} provider
+ * @property {string} aggregator
+ * @property {number} duration
+ * @property {number} lft
+ * @property {number} rght
+ * @property {string[]} learning_activities
+ * @property {string[]} grade_levels
+ * @property {string[]} accessibility_labels
+ * @property {string[]} categories
+ * @property {string[]} resource_types
+ * @property {string[]} tags
+ * @property {boolean} coach_content
+ * @property {string} options - JSON string
+ * @property {string} thumbnail - storage URL path
+ * @property {string} license_name
+ * @property {string} license_description
+ * @property {string} license_owner
+ * @property {number} num_coach_contents
+ * @property {{id: string, lang_name: string, lang_code: string, lang_direction: string}} lang
+ * @property {PublicFile[]} files
+ */
+
+/**
+ * @typedef {Object} PublicChannelMetadata
+ * @property {string} id
+ * @property {string} root
+ * @property {string} name
+ * @property {string} description
+ * @property {string} thumbnail - data URI
+ * @property {string[]} included_languages
+ * @property {string} lang_code
+ * @property {string} lang_name
+ * @property {string} author
+ * @property {boolean} public
+ * @property {number} published_size
+ * @property {number} num_coach_contents
+ * @property {number} total_resource_count
+ * @property {number} version
+ * @property {string} last_published
+ * @property {string} last_updated
+ *
+ */
diff --git a/contentcuration/contentcuration/frontend/shared/data/resources.js b/contentcuration/contentcuration/frontend/shared/data/resources.js
index 3843753b6b..2575bfc3f9 100644
--- a/contentcuration/contentcuration/frontend/shared/data/resources.js
+++ b/contentcuration/contentcuration/frontend/shared/data/resources.js
@@ -1347,10 +1347,11 @@ export const ContentNode = new TreeResource({
    * @param {string} target
    * @param {string} position
    * @param {Boolean} isCreate
+   * @param {Object} [sourceNode]
    * @param {Function<Promise<ContentNode>>} callback
    * @return {Promise<ContentNode>}
    */
-  resolveTreeInsert(id, target, position, isCreate, callback) {
+  resolveTreeInsert({ id, target, position, isCreate, sourceNode = null }, callback) {
     // First, resolve parent so we can determine the sort order, but also to determine
     // the tree so we can temporarily lock it while we determine those values locally
     return this.resolveParent(target, position).then(parent => {
@@ -1361,8 +1362,12 @@ export const ContentNode = new TreeResource({
       // Using root_id, we'll keep this locked while we handle this, so no other operations
       // happen while we're potentially waiting for some data we need (siblings, source node)
       return this.treeLock(parent.root_id, () => {
-        // Don't trigger fetch, if this is specified as a creation
-        const getNode = isCreate ? this.table.get(id) : this.get(id, false);
+        // Resolve to sourceNode passed in if a create
+        let getNode = Promise.resolve(sourceNode);
+        if (!sourceNode) {
+          // Don't trigger fetch, if this is specified as a creation
+          getNode = isCreate ? this.table.get(id) : this.get(id, false);
+        }
 
         // Preload the ID we're referencing, and get siblings to determine sort order
         return Promise.all([getNode, this.where({ parent: parent.id }, false)]).then(
@@ -1429,10 +1434,12 @@ export const ContentNode = new TreeResource({
     const prepared = this._prepareAdd(obj);
 
     return this.resolveTreeInsert(
-      prepared.id,
-      prepared.parent,
-      RELATIVE_TREE_POSITIONS.LAST_CHILD,
-      true,
+      {
+        id: prepared.id,
+        target: prepared.parent,
+        position: RELATIVE_TREE_POSITIONS.LAST_CHILD,
+        isCreate: true,
+      },
       data => {
         return this.transaction({ mode: 'rw' }, CHANGES_TABLE, () => {
           const obj = { ...prepared, ...data.payload };
@@ -1445,7 +1452,7 @@ export const ContentNode = new TreeResource({
   },
 
   move(id, target, position = RELATIVE_TREE_POSITIONS.FIRST_CHILD) {
-    return this.resolveTreeInsert(id, target, position, false, data => {
+    return this.resolveTreeInsert({ id, target, position, isCreate: false }, data => {
       return this.transaction({ mode: 'rw' }, CHANGES_TABLE, async () => {
         const payload = await this.tableMove(data);
         const change = new MovedChange(data.changeData);
@@ -1480,9 +1487,16 @@ export const ContentNode = new TreeResource({
    * @param {string} target The ID of the target node used for positioning
    * @param {string} position The position relative to `target`
    * @param {Object|null} [excluded_descendants] a map of node_ids to exclude from the copy
+   * @param {Object|null} [sourceNode] a source node to use for the copy instead of fetching
    * @return {Promise}
    */
-  copy(id, target, position = RELATIVE_TREE_POSITIONS.LAST_CHILD, excluded_descendants = null) {
+  copy(
+    id,
+    target,
+    position = RELATIVE_TREE_POSITIONS.LAST_CHILD,
+    excluded_descendants = null,
+    sourceNode = null
+  ) {
     if (process.env.NODE_ENV !== 'production' && process.env.NODE_ENV !== 'test') {
       /* eslint-disable no-console */
       console.groupCollapsed(`Copying contentnode from ${id} with target ${target}`);
@@ -1491,7 +1505,7 @@ export const ContentNode = new TreeResource({
       /* eslint-enable */
     }
 
-    return this.resolveTreeInsert(id, target, position, true, data => {
+    return this.resolveTreeInsert({ id, target, position, isCreate: true, sourceNode }, data => {
       data.changeData.excluded_descendants = excluded_descendants;
       data.changeData.mods = {};
 
diff --git a/contentcuration/contentcuration/frontend/shared/views/form/DropdownWrapper.vue b/contentcuration/contentcuration/frontend/shared/views/form/DropdownWrapper.vue
index 56c38b0f58..63c39805cf 100644
--- a/contentcuration/contentcuration/frontend/shared/views/form/DropdownWrapper.vue
+++ b/contentcuration/contentcuration/frontend/shared/views/form/DropdownWrapper.vue
@@ -31,8 +31,12 @@
         default: 'div',
       },
       menuHeight: {
-        type: Number,
+        type: [Number, String],
         default: 300,
+        validator: value => {
+          const parsed = parseInt(value, 10);
+          return !isNaN(parsed) && parsed > 0;
+        },
       },
     },
     data() {
diff --git a/contentcuration/search/viewsets/contentnode.py b/contentcuration/search/viewsets/contentnode.py
index 676698031d..199c78817d 100644
--- a/contentcuration/search/viewsets/contentnode.py
+++ b/contentcuration/search/viewsets/contentnode.py
@@ -104,38 +104,44 @@ class SearchContentNodeViewSet(ReadOnlyValuesViewset):
         "id": "contentnode__id",
         "content_id": "contentnode__content_id",
         "node_id": "contentnode__node_id",
+        "root_id": "channel__main_tree_id",
         "title": "contentnode__title",
         "description": "contentnode__description",
         "author": "contentnode__author",
         "provider": "contentnode__provider",
-        "kind__kind": "contentnode__kind__kind",
+        "kind": "contentnode__kind__kind",
         "thumbnail_encoding": "contentnode__thumbnail_encoding",
         "published": "contentnode__published",
         "modified": "contentnode__modified",
-        "parent_id": "contentnode__parent_id",
+        "parent": "contentnode__parent_id",
         "changed": "contentnode__changed",
+        "public": "channel__public",
     }
 
     values = (
+        "channel__public",
+        "channel__main_tree_id",
         "contentnode__id",
         "contentnode__content_id",
         "contentnode__node_id",
-        "contentnode__title",
-        "contentnode__description",
-        "contentnode__author",
-        "contentnode__provider",
         "contentnode__kind__kind",
-        "contentnode__thumbnail_encoding",
-        "contentnode__published",
-        "contentnode__modified",
         "contentnode__parent_id",
-        "contentnode__changed",
         "channel_id",
         "resource_count",
-        "thumbnail_checksum",
-        "thumbnail_extension",
-        "content_tags",
         "original_channel_name",
+
+        # TODO: currently loading nodes separately
+        # "thumbnail_checksum",
+        # "thumbnail_extension",
+        # "content_tags",
+        # "contentnode__title",
+        # "contentnode__description",
+        # "contentnode__author",
+        # "contentnode__provider",
+        # "contentnode__changed",
+        # "contentnode__thumbnail_encoding",
+        # "contentnode__published",
+        # "contentnode__modified",
     )
 
     def annotate_queryset(self, queryset):