diff --git a/apis/api-languages/src/schema/language/index.ts b/apis/api-languages/src/schema/language/index.ts
index c7791ad1771..b70cce70f2e 100644
--- a/apis/api-languages/src/schema/language/index.ts
+++ b/apis/api-languages/src/schema/language/index.ts
@@ -1,4 +1,5 @@
 import './language'
 import './audioPreview'
+import './languageName'
 
 export { Language } from './language'
diff --git a/apis/api-languages/src/schema/language/language.ts b/apis/api-languages/src/schema/language/language.ts
index e17562936ef..e6a68fb1175 100644
--- a/apis/api-languages/src/schema/language/language.ts
+++ b/apis/api-languages/src/schema/language/language.ts
@@ -1,7 +1,9 @@
 import { Prisma, prisma } from '@core/prisma/languages/client'
 
+import { updateLanguageInAlgolia } from '../../lib/algolia/algoliaLanguageUpdate/algoliaLanguageUpdate'
 import { parseFullTextSearch } from '../../lib/parseFullTextSearch'
 import { builder } from '../builder'
+import { logger } from '../logger'
 
 enum LanguageIdType {
   databaseId = 'databaseId',
@@ -158,3 +160,47 @@ builder.queryFields((t) => ({
     }
   })
 }))
+
+builder.mutationFields((t) => ({
+  languageUpdate: t.withAuth({ isPublisher: true }).prismaFieldWithInput({
+    type: 'Language',
+    nullable: false,
+    input: {
+      id: t.input.id({ required: true }),
+      bcp47: t.input.string({ required: false }),
+      iso3: t.input.string({ required: false }),
+      slug: t.input.string({ required: false }),
+      hasVideos: t.input.boolean({ required: false })
+    },
+    resolve: async (
+      query,
+      _parent,
+      { input: { id, bcp47, iso3, slug, hasVideos } }
+    ) => {
+      const data: Prisma.LanguageUpdateInput = {}
+
+      if (bcp47 !== undefined) data.bcp47 = bcp47
+      if (iso3 !== undefined) data.iso3 = iso3
+      if (slug !== undefined) data.slug = slug
+      if (hasVideos !== undefined) data.hasVideos = hasVideos
+
+      if (Object.keys(data).length === 0) {
+        throw new Error('No fields provided to update')
+      }
+
+      const language = await prisma.language.update({
+        ...query,
+        where: { id },
+        data
+      })
+
+      try {
+        await updateLanguageInAlgolia(language.id, logger)
+      } catch (err) {
+        logger.error({ err, languageId: language.id }, 'Algolia update error')
+      }
+
+      return language
+    }
+  })
+}))
diff --git a/apis/api-languages/src/schema/language/languageName/index.ts b/apis/api-languages/src/schema/language/languageName/index.ts
new file mode 100644
index 00000000000..da9fdeae523
--- /dev/null
+++ b/apis/api-languages/src/schema/language/languageName/index.ts
@@ -0,0 +1,2 @@
+import './languageName'
+
diff --git a/apis/api-languages/src/schema/language/languageName/languageName.ts b/apis/api-languages/src/schema/language/languageName/languageName.ts
new file mode 100644
index 00000000000..b51dd911732
--- /dev/null
+++ b/apis/api-languages/src/schema/language/languageName/languageName.ts
@@ -0,0 +1,145 @@
+import { Prisma, prisma } from '@core/prisma/languages/client'
+
+import { updateLanguageInAlgolia } from '../../../lib/algolia/algoliaLanguageUpdate/algoliaLanguageUpdate'
+import { builder } from '../../builder'
+import { logger } from '../../logger'
+
+type LanguageNameWhereUniqueInput = {
+  parentLanguageId: string
+  languageId: string
+}
+
+function toWhereUnique({
+  parentLanguageId,
+  languageId
+}: LanguageNameWhereUniqueInput): Prisma.LanguageNameWhereUniqueInput {
+  return {
+    parentLanguageId_languageId: {
+      parentLanguageId,
+      languageId
+    }
+  }
+}
+
+builder.mutationFields((t) => ({
+  languageNameCreate: t.withAuth({ isPublisher: true }).prismaFieldWithInput({
+    type: 'LanguageName',
+    nullable: false,
+    input: {
+      parentLanguageId: t.input.id({ required: true }),
+      languageId: t.input.id({ required: true }),
+      value: t.input.string({ required: true }),
+      primary: t.input.boolean({ required: true })
+    },
+    resolve: async (
+      query,
+      _parent,
+      { input: { parentLanguageId, languageId, value, primary } }
+    ) => {
+      const created = await prisma.$transaction(async (tx) => {
+        if (primary) {
+          await tx.languageName.updateMany({
+            where: { parentLanguageId, primary: true },
+            data: { primary: false }
+          })
+        }
+
+        return await tx.languageName.create({
+          ...query,
+          data: {
+            parentLanguageId,
+            languageId,
+            value,
+            primary
+          }
+        })
+      })
+
+      try {
+        await updateLanguageInAlgolia(parentLanguageId, logger)
+      } catch (err) {
+        logger.error(
+          { err, parentLanguageId, languageId },
+          'Algolia update error after languageNameCreate'
+        )
+      }
+
+      return created
+    }
+  }),
+  languageNameUpdate: t.withAuth({ isPublisher: true }).prismaFieldWithInput({
+    type: 'LanguageName',
+    nullable: false,
+    input: {
+      parentLanguageId: t.input.id({ required: true }),
+      languageId: t.input.id({ required: true }),
+      value: t.input.string({ required: false }),
+      primary: t.input.boolean({ required: false })
+    },
+    resolve: async (
+      query,
+      _parent,
+      { input: { parentLanguageId, languageId, value, primary } }
+    ) => {
+      const data: Prisma.LanguageNameUpdateInput = {}
+      if (value !== undefined) data.value = value
+      if (primary !== undefined) data.primary = primary
+
+      if (Object.keys(data).length === 0) {
+        throw new Error('No fields provided to update')
+      }
+
+      const updated = await prisma.$transaction(async (tx) => {
+        if (primary === true) {
+          await tx.languageName.updateMany({
+            where: { parentLanguageId, primary: true },
+            data: { primary: false }
+          })
+        }
+
+        return await tx.languageName.update({
+          ...query,
+          where: toWhereUnique({ parentLanguageId, languageId }),
+          data
+        })
+      })
+
+      try {
+        await updateLanguageInAlgolia(parentLanguageId, logger)
+      } catch (err) {
+        logger.error(
+          { err, parentLanguageId, languageId },
+          'Algolia update error after languageNameUpdate'
+        )
+      }
+
+      return updated
+    }
+  }),
+  languageNameDelete: t.withAuth({ isPublisher: true }).prismaFieldWithInput({
+    type: 'LanguageName',
+    nullable: false,
+    input: {
+      parentLanguageId: t.input.id({ required: true }),
+      languageId: t.input.id({ required: true })
+    },
+    resolve: async (query, _parent, { input: { parentLanguageId, languageId } }) => {
+      const deleted = await prisma.languageName.delete({
+        ...query,
+        where: toWhereUnique({ parentLanguageId, languageId })
+      })
+
+      try {
+        await updateLanguageInAlgolia(parentLanguageId, logger)
+      } catch (err) {
+        logger.error(
+          { err, parentLanguageId, languageId },
+          'Algolia update error after languageNameDelete'
+        )
+      }
+
+      return deleted
+    }
+  })
+}))
+