diff --git a/packages/client/src/graphql/graphql.ts b/packages/client/src/graphql/graphql.ts
index 60097ca4..ea12a1c6 100644
--- a/packages/client/src/graphql/graphql.ts
+++ b/packages/client/src/graphql/graphql.ts
@@ -59,6 +59,12 @@ export type DatasetCreate = {
   name: Scalars['String']['input'];
 };
 
+export type DatasetProjectPermission = {
+  __typename?: 'DatasetProjectPermission';
+  dataset: Dataset;
+  projectHasAccess: Scalars['Boolean']['output'];
+};
+
 export type EmailLoginDto = {
   email: Scalars['String']['input'];
   password: Scalars['String']['input'];
@@ -191,6 +197,7 @@ export type Mutation = {
   forgotPassword: Scalars['Boolean']['output'];
   grantContributor: Scalars['Boolean']['output'];
   grantOwner: Scalars['Boolean']['output'];
+  grantProjectDatasetAccess: Scalars['Boolean']['output'];
   grantProjectPermissions: Scalars['Boolean']['output'];
   grantStudyAdmin: Scalars['Boolean']['output'];
   grantTrainedContributor: Scalars['Boolean']['output'];
@@ -327,6 +334,13 @@ export type MutationGrantOwnerArgs = {
 };
 
 
+export type MutationGrantProjectDatasetAccessArgs = {
+  dataset: Scalars['ID']['input'];
+  hasAccess: Scalars['Boolean']['input'];
+  project: Scalars['ID']['input'];
+};
+
+
 export type MutationGrantProjectPermissionsArgs = {
   isAdmin: Scalars['Boolean']['input'];
   project: Scalars['ID']['input'];
@@ -520,7 +534,9 @@ export type Query = {
   findStudies: Array<Study>;
   /** Get the presigned URL for where to upload the CSV against */
   getCSVUploadURL: Scalars['String']['output'];
+  getDatasetProjectPermissions: Array<DatasetProjectPermission>;
   getDatasets: Array<Dataset>;
+  getDatasetsByProject: Array<Dataset>;
   getEntryUploadURL: Scalars['String']['output'];
   getOrganizations: Array<Organization>;
   getProject: ProjectModel;
@@ -564,6 +580,16 @@ export type QueryGetCsvUploadUrlArgs = {
 };
 
 
+export type QueryGetDatasetProjectPermissionsArgs = {
+  project: Scalars['ID']['input'];
+};
+
+
+export type QueryGetDatasetsByProjectArgs = {
+  project: Scalars['ID']['input'];
+};
+
+
 export type QueryGetEntryUploadUrlArgs = {
   contentType: Scalars['String']['input'];
   filename: Scalars['String']['input'];
diff --git a/packages/client/src/graphql/permission/permission.graphql b/packages/client/src/graphql/permission/permission.graphql
index cc83040e..95dc0fc8 100644
--- a/packages/client/src/graphql/permission/permission.graphql
+++ b/packages/client/src/graphql/permission/permission.graphql
@@ -53,3 +53,18 @@ mutation grantContributor($study: ID!, $user: ID!, $isContributor: Boolean!) {
 mutation grantTrainedContributor($study: ID!, $user: ID!, $isTrained: Boolean!) {
   grantTrainedContributor(study: $study, user: $user, isTrained: $isTrained)
 }
+
+query getDatasetProjectPermissions($project: ID!) {
+  getDatasetProjectPermissions(project: $project) {
+    dataset {
+      _id,
+      name,
+      description
+    },
+    projectHasAccess
+  }
+}
+
+mutation grantProjectDatasetAccess($project: ID!, $dataset: ID!, $hasAccess: Boolean!) {
+  grantProjectDatasetAccess(project: $project, dataset: $dataset, hasAccess: $hasAccess)
+}
diff --git a/packages/client/src/graphql/permission/permission.ts b/packages/client/src/graphql/permission/permission.ts
index 1ff00999..6408aaa3 100644
--- a/packages/client/src/graphql/permission/permission.ts
+++ b/packages/client/src/graphql/permission/permission.ts
@@ -55,6 +55,22 @@ export type GrantTrainedContributorMutationVariables = Types.Exact<{
 
 export type GrantTrainedContributorMutation = { __typename?: 'Mutation', grantTrainedContributor: boolean };
 
+export type GetDatasetProjectPermissionsQueryVariables = Types.Exact<{
+  project: Types.Scalars['ID']['input'];
+}>;
+
+
+export type GetDatasetProjectPermissionsQuery = { __typename?: 'Query', getDatasetProjectPermissions: Array<{ __typename?: 'DatasetProjectPermission', projectHasAccess: boolean, dataset: { __typename?: 'Dataset', _id: string, name: string, description: string } }> };
+
+export type GrantProjectDatasetAccessMutationVariables = Types.Exact<{
+  project: Types.Scalars['ID']['input'];
+  dataset: Types.Scalars['ID']['input'];
+  hasAccess: Types.Scalars['Boolean']['input'];
+}>;
+
+
+export type GrantProjectDatasetAccessMutation = { __typename?: 'Mutation', grantProjectDatasetAccess: boolean };
+
 
 export const GetProjectPermissionsDocument = gql`
     query getProjectPermissions($project: ID!) {
@@ -285,4 +301,81 @@ export function useGrantTrainedContributorMutation(baseOptions?: Apollo.Mutation
       }
 export type GrantTrainedContributorMutationHookResult = ReturnType<typeof useGrantTrainedContributorMutation>;
 export type GrantTrainedContributorMutationResult = Apollo.MutationResult<GrantTrainedContributorMutation>;
-export type GrantTrainedContributorMutationOptions = Apollo.BaseMutationOptions<GrantTrainedContributorMutation, GrantTrainedContributorMutationVariables>;
\ No newline at end of file
+export type GrantTrainedContributorMutationOptions = Apollo.BaseMutationOptions<GrantTrainedContributorMutation, GrantTrainedContributorMutationVariables>;
+export const GetDatasetProjectPermissionsDocument = gql`
+    query getDatasetProjectPermissions($project: ID!) {
+  getDatasetProjectPermissions(project: $project) {
+    dataset {
+      _id
+      name
+      description
+    }
+    projectHasAccess
+  }
+}
+    `;
+
+/**
+ * __useGetDatasetProjectPermissionsQuery__
+ *
+ * To run a query within a React component, call `useGetDatasetProjectPermissionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetDatasetProjectPermissionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetDatasetProjectPermissionsQuery({
+ *   variables: {
+ *      project: // value for 'project'
+ *   },
+ * });
+ */
+export function useGetDatasetProjectPermissionsQuery(baseOptions: Apollo.QueryHookOptions<GetDatasetProjectPermissionsQuery, GetDatasetProjectPermissionsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetDatasetProjectPermissionsQuery, GetDatasetProjectPermissionsQueryVariables>(GetDatasetProjectPermissionsDocument, options);
+      }
+export function useGetDatasetProjectPermissionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDatasetProjectPermissionsQuery, GetDatasetProjectPermissionsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetDatasetProjectPermissionsQuery, GetDatasetProjectPermissionsQueryVariables>(GetDatasetProjectPermissionsDocument, options);
+        }
+export type GetDatasetProjectPermissionsQueryHookResult = ReturnType<typeof useGetDatasetProjectPermissionsQuery>;
+export type GetDatasetProjectPermissionsLazyQueryHookResult = ReturnType<typeof useGetDatasetProjectPermissionsLazyQuery>;
+export type GetDatasetProjectPermissionsQueryResult = Apollo.QueryResult<GetDatasetProjectPermissionsQuery, GetDatasetProjectPermissionsQueryVariables>;
+export const GrantProjectDatasetAccessDocument = gql`
+    mutation grantProjectDatasetAccess($project: ID!, $dataset: ID!, $hasAccess: Boolean!) {
+  grantProjectDatasetAccess(
+    project: $project
+    dataset: $dataset
+    hasAccess: $hasAccess
+  )
+}
+    `;
+export type GrantProjectDatasetAccessMutationFn = Apollo.MutationFunction<GrantProjectDatasetAccessMutation, GrantProjectDatasetAccessMutationVariables>;
+
+/**
+ * __useGrantProjectDatasetAccessMutation__
+ *
+ * To run a mutation, you first call `useGrantProjectDatasetAccessMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useGrantProjectDatasetAccessMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [grantProjectDatasetAccessMutation, { data, loading, error }] = useGrantProjectDatasetAccessMutation({
+ *   variables: {
+ *      project: // value for 'project'
+ *      dataset: // value for 'dataset'
+ *      hasAccess: // value for 'hasAccess'
+ *   },
+ * });
+ */
+export function useGrantProjectDatasetAccessMutation(baseOptions?: Apollo.MutationHookOptions<GrantProjectDatasetAccessMutation, GrantProjectDatasetAccessMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useMutation<GrantProjectDatasetAccessMutation, GrantProjectDatasetAccessMutationVariables>(GrantProjectDatasetAccessDocument, options);
+      }
+export type GrantProjectDatasetAccessMutationHookResult = ReturnType<typeof useGrantProjectDatasetAccessMutation>;
+export type GrantProjectDatasetAccessMutationResult = Apollo.MutationResult<GrantProjectDatasetAccessMutation>;
+export type GrantProjectDatasetAccessMutationOptions = Apollo.BaseMutationOptions<GrantProjectDatasetAccessMutation, GrantProjectDatasetAccessMutationVariables>;
\ No newline at end of file
diff --git a/packages/client/src/pages/datasets/ProjectAccess.tsx b/packages/client/src/pages/datasets/ProjectAccess.tsx
index 5a400b30..9fb082c8 100644
--- a/packages/client/src/pages/datasets/ProjectAccess.tsx
+++ b/packages/client/src/pages/datasets/ProjectAccess.tsx
@@ -1,78 +1,85 @@
-import { Accordion, Box, Container, Typography } from '@mui/material';
-import AccordionSummary from '@mui/material/AccordionSummary';
-import AccordionDetails from '@mui/material/AccordionDetails';
-import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
-import { DatasetAccess } from '../../components/DatasetAccess.component';
-
-const rows = [
-  {
-    id: 1,
-    name: 'Project Flour',
-    description:
-      'Led by James Beard Award-winning pastry chef + co-owner Joanne Chang, Flour Bakery now has nine locations in Boston + Cambridge. We offer buttery breakfast pastries; soft + chewy cookies; luscious pies; gorgeous cakes; and fresh, made-to-order sandwiches, soups, and salads - all prepared daily by our dedicated team.',
-    access: true
-  },
-  {
-    id: 2,
-    name: 'Project Tesla',
-    description:
-      'The Energy Generation and Storage segment engages in the design, manufacture, installation, sale, and leasing of solar energy generation and energy storage products, and related services to residential, commercial, and industrial customers and utilities through its website, stores, and galleries, as well as through a network of channel partners',
-    access: true
-  },
-  {
-    id: 3,
-    name: 'Project Starbucks',
-    description:
-      'The company was founded by Steven Paul Jobs, Ronald Gerald Wayne, and Stephen G. Wozniak on April 1, 1976 and is headquartered in Cupertino, CA.',
-    access: true
-  },
-  {
-    id: 4,
-    name: 'Project Charles',
-    description:
-      'Investment, wealth and alternative managers, asset owners and insurers in over 30 countries rely on Charles River IMS to manage USD $48 Trillion in assets.',
-    access: false
-  }
-];
+import { Typography, Switch } from '@mui/material';
+import { useProject } from '../../context/Project.context';
+import { DataGrid, GridColDef } from '@mui/x-data-grid';
+import { useGetDatasetProjectPermissionsLazyQuery } from '../../graphql/permission/permission';
+import { useEffect, useState } from 'react';
+import { DatasetProjectPermission, Project } from '../../graphql/graphql';
+import { useGrantProjectDatasetAccessMutation } from '../../graphql/permission/permission';
 
 export const ProjectAccess: React.FC = () => {
+  const { project } = useProject();
+  const [getDatasetProjectPermissions, datasetProjectPermissionResults] = useGetDatasetProjectPermissionsLazyQuery();
+  const [projectAccess, setProjectAccess] = useState<DatasetProjectPermission[]>([]);
+  const [grantProjectDatasetAccess, grantProjectDatasetAccessResults] = useGrantProjectDatasetAccessMutation();
+
+  // For querying for the permissions
+  useEffect(() => {
+    if (project) {
+      getDatasetProjectPermissions({ variables: { project: project._id } });
+    }
+  }, [project]);
+
+  // For setting the permissions
+  useEffect(() => {
+    if (datasetProjectPermissionResults.data) {
+      setProjectAccess(datasetProjectPermissionResults.data.getDatasetProjectPermissions);
+    }
+  }, [datasetProjectPermissionResults]);
+
+  // For updating the permissions
+  useEffect(() => {
+    if (grantProjectDatasetAccessResults.data) {
+      datasetProjectPermissionResults.refetch();
+    }
+  }, [grantProjectDatasetAccessResults]);
+
+  const handleAccessChange = (dataset: string, project: string, hasAccess: boolean) => {
+    grantProjectDatasetAccess({ variables: { dataset, project, hasAccess } });
+  };
+
+  const columns: GridColDef[] = [
+    { field: 'name', headerName: 'Dataset Name', width: 200, valueGetter: (params) => params.row.dataset.name },
+    {
+      field: 'description',
+      headerName: 'Description',
+      width: 200,
+      valueGetter: (params) => params.row.dataset.description
+    },
+    {
+      field: 'access',
+      headerName: 'Project Has Access',
+      width: 200,
+      renderCell: (params) => (
+        <DatasetAccess permission={params.row} project={project!} changeAccess={handleAccessChange} />
+      )
+    }
+  ];
+
   return (
     <>
-      <Typography variant="h5">Project Access</Typography>
-      <Accordion disableGutters>
-        <AccordionSummary expandIcon={<ExpandMoreIcon />} aria-controls="panel1a-content" id="panel1a-header">
-          <Typography sx={{ fontSize: '15px', position: 'absolute', top: '14px', left: '3%' }}>
-            Dataset 1 name
-          </Typography>
-          <Typography sx={{ fontSize: '15px', position: 'absolute', top: '14px', right: '52%' }}>
-            Dataset 1 description
-          </Typography>
-        </AccordionSummary>
-        <AccordionDetails>
-          <Container sx={{ width: '100%', display: 'flex', flexDirection: 'column', justifyContext: 'space-between' }}>
-            <Box sx={{ position: '-webkit-sticky' }}>
-              <DatasetAccess tableRows={rows} />
-            </Box>
-          </Container>
-        </AccordionDetails>
-      </Accordion>
-      <Accordion disableGutters>
-        <AccordionSummary expandIcon={<ExpandMoreIcon />} aria-controls="panel2a-content" id="panel2a-header">
-          <Typography sx={{ fontSize: '15px', position: 'absolute', top: '14px', left: '3%' }}>
-            Dataset 2 name
-          </Typography>
-          <Typography sx={{ fontSize: '15px', position: 'absolute', top: '14px', right: '52%' }}>
-            Dataset2 description
-          </Typography>
-        </AccordionSummary>
-        <AccordionDetails>
-          <Container sx={{ width: '100%', display: 'flex', flexDirection: 'column', justifyContext: 'space-between' }}>
-            <Box sx={{ position: '-webkit-sticky' }}>
-              <DatasetAccess tableRows={rows} />
-            </Box>
-          </Container>
-        </AccordionDetails>
-      </Accordion>
+      {project ? (
+        <>
+          <Typography variant="h5">Dataset Access for "{project.name}"</Typography>
+          <DataGrid columns={columns} rows={projectAccess} getRowId={(row) => row.dataset._id} />
+        </>
+      ) : (
+        <Typography variant="h5">Select a Project to Continue</Typography>
+      )}
     </>
   );
 };
+
+interface DatasetAccessProps {
+  permission: DatasetProjectPermission;
+  project: Project;
+  changeAccess: (dataset: string, project: string, access: boolean) => void;
+}
+
+const DatasetAccess: React.FC<DatasetAccessProps> = ({ permission, changeAccess, project }) => {
+  return (
+    <Switch
+      checked={permission.projectHasAccess}
+      onChange={(event) => changeAccess(permission.dataset._id, project._id, event.target.checked)}
+    />
+  );
+};
diff --git a/packages/server/schema.gql b/packages/server/schema.gql
index 8e64ef5b..ecfe2eed 100644
--- a/packages/server/schema.gql
+++ b/packages/server/schema.gql
@@ -68,6 +68,11 @@ type StudyPermissionModel {
   isTrainedEditable: Boolean!
 }
 
+type DatasetProjectPermission {
+  dataset: Dataset!
+  projectHasAccess: Boolean!
+}
+
 type Entry {
   _id: String!
   organization: ID!
@@ -128,8 +133,10 @@ type Query {
   getOrganizations: [Organization!]!
   exists(name: String!): Boolean!
   getDatasets: [Dataset!]!
+  getDatasetsByProject(project: ID!): [Dataset!]!
   getProjectPermissions(project: ID!): [ProjectPermissionModel!]!
   getStudyPermissions(study: ID!): [StudyPermissionModel!]!
+  getDatasetProjectPermissions(project: ID!): [DatasetProjectPermission!]!
   projectExists(name: String!): Boolean!
   getProjects: [Project!]!
   studyExists(name: String!, project: ID!): Boolean!
@@ -152,6 +159,7 @@ type Mutation {
   grantStudyAdmin(study: ID!, user: ID!, isAdmin: Boolean!): Boolean!
   grantContributor(study: ID!, user: ID!, isContributor: Boolean!): Boolean!
   grantTrainedContributor(study: ID!, user: ID!, isTrained: Boolean!): Boolean!
+  grantProjectDatasetAccess(project: ID!, dataset: ID!, hasAccess: Boolean!): Boolean!
   signLabCreateProject(project: ProjectCreate!): Project!
   deleteProject(project: ID!): Boolean!
   createStudy(study: StudyCreate!): Study!
diff --git a/packages/server/src/dataset/dataset.module.ts b/packages/server/src/dataset/dataset.module.ts
index 898e65ad..2bdcff3b 100644
--- a/packages/server/src/dataset/dataset.module.ts
+++ b/packages/server/src/dataset/dataset.module.ts
@@ -1,4 +1,4 @@
-import { Module } from '@nestjs/common';
+import { Module, forwardRef } from '@nestjs/common';
 import { DatasetResolver } from './dataset.resolver';
 import { DatasetService } from './dataset.service';
 import { MongooseModule } from '@nestjs/mongoose';
@@ -6,9 +6,15 @@ import { Dataset, DatasetSchema } from './dataset.model';
 import { DatasetPipe } from './pipes/dataset.pipe';
 import { PermissionModule } from '../permission/permission.module';
 import { JwtModule } from '../jwt/jwt.module';
+import { ProjectModule } from '../project/project.module';
 
 @Module({
-  imports: [MongooseModule.forFeature([{ name: Dataset.name, schema: DatasetSchema }]), PermissionModule, JwtModule],
+  imports: [
+    MongooseModule.forFeature([{ name: Dataset.name, schema: DatasetSchema }]),
+    forwardRef(() => PermissionModule),
+    JwtModule,
+    ProjectModule
+  ],
   providers: [DatasetResolver, DatasetService, DatasetPipe],
   exports: [DatasetService, DatasetPipe]
 })
diff --git a/packages/server/src/dataset/dataset.resolver.ts b/packages/server/src/dataset/dataset.resolver.ts
index 1629174e..0d0cedf7 100644
--- a/packages/server/src/dataset/dataset.resolver.ts
+++ b/packages/server/src/dataset/dataset.resolver.ts
@@ -12,6 +12,9 @@ import * as casbin from 'casbin';
 import { TokenContext } from '../jwt/token.context';
 import { TokenPayload } from '../jwt/token.dto';
 import { DatasetPermissions } from '../permission/permissions/dataset';
+import { ProjectPipe } from '../project/pipes/project.pipe';
+import { Project } from '../project/project.model';
+import { ProjectPermissions } from '../permission/permissions/project';
 
 // TODO: Add authentication
 @UseGuards(JwtAuthGuard)
@@ -80,4 +83,17 @@ export class DatasetResolver {
 
     return true;
   }
+
+  @Query(() => [Dataset])
+  async getDatasetsByProject(
+    @Args('project', { type: () => ID }, ProjectPipe) project: Project,
+    @TokenContext() user: TokenPayload
+  ): Promise<Dataset[]> {
+    // Make sure the user has access to the project
+    if (!(await this.enforcer.enforce(user.id, ProjectPermissions.READ, project._id))) {
+      throw new UnauthorizedException('User does not have permission to read this project');
+    }
+
+    return this.datasetService.findByProject(project);
+  }
 }
diff --git a/packages/server/src/dataset/dataset.service.ts b/packages/server/src/dataset/dataset.service.ts
index 8e2c2097..b0d3245f 100644
--- a/packages/server/src/dataset/dataset.service.ts
+++ b/packages/server/src/dataset/dataset.service.ts
@@ -6,6 +6,7 @@ import { DatasetCreate } from './dtos/create.dto';
 import { ConfigService } from '@nestjs/config';
 import { CASBIN_PROVIDER } from '../permission/casbin.provider';
 import * as casbin from 'casbin';
+import { Project } from '../project/project.model';
 
 @Injectable()
 export class DatasetService {
@@ -51,4 +52,17 @@ export class DatasetService {
   async changeDescription(dataset: Dataset, newDescription: string): Promise<void> {
     await this.datasetModel.updateOne({ _id: dataset._id }, { $set: { description: newDescription } });
   }
+
+  /** Get datasets a given project has access to */
+  async findByProject(project: Project): Promise<Dataset[]> {
+    const datasets = await this.datasetModel.find({ organization: project.organization });
+    const filteredDatasets: Dataset[] = [];
+    for (const dataset of datasets) {
+      if (await this.enforcer.hasNamedGroupingPolicy('g2', project._id.toString(), dataset._id.toString())) {
+        filteredDatasets.push(dataset);
+      }
+    }
+
+    return filteredDatasets;
+  }
 }
diff --git a/packages/server/src/permission/models/dataset.model.ts b/packages/server/src/permission/models/dataset.model.ts
new file mode 100644
index 00000000..37b50b27
--- /dev/null
+++ b/packages/server/src/permission/models/dataset.model.ts
@@ -0,0 +1,11 @@
+import { ObjectType, Field } from '@nestjs/graphql';
+import { Dataset } from '../../dataset/dataset.model';
+
+@ObjectType()
+export class DatasetProjectPermission {
+  @Field(() => Dataset)
+  dataset: string;
+
+  @Field()
+  projectHasAccess: boolean;
+}
diff --git a/packages/server/src/permission/permission.module.ts b/packages/server/src/permission/permission.module.ts
index 8d4915a2..a0f123f2 100644
--- a/packages/server/src/permission/permission.module.ts
+++ b/packages/server/src/permission/permission.module.ts
@@ -7,15 +7,23 @@ import { StudyModule } from '../study/study.module';
 import { ProjectPermissionResolver } from './resolvers/project.resolver';
 import { OwnerPermissionResolver } from './resolvers/owner.resolver';
 import { StudyPermissionResolver } from './resolvers/study.resolver';
+import { DatasetPermissionResolver } from './resolvers/dataset.resolver';
+import { DatasetModule } from '../dataset/dataset.module';
 
 @Module({
-  imports: [forwardRef(() => ProjectModule), AuthModule, forwardRef(() => StudyModule)],
+  imports: [
+    forwardRef(() => ProjectModule),
+    AuthModule,
+    forwardRef(() => StudyModule),
+    forwardRef(() => DatasetModule)
+  ],
   providers: [
     casbinProvider,
     PermissionService,
     ProjectPermissionResolver,
     OwnerPermissionResolver,
-    StudyPermissionResolver
+    StudyPermissionResolver,
+    DatasetPermissionResolver
   ],
   exports: [casbinProvider]
 })
diff --git a/packages/server/src/permission/permission.service.ts b/packages/server/src/permission/permission.service.ts
index 3792ad0f..242f5870 100644
--- a/packages/server/src/permission/permission.service.ts
+++ b/packages/server/src/permission/permission.service.ts
@@ -8,12 +8,16 @@ import { TokenPayload } from '../jwt/token.dto';
 import { Study } from '../study/study.model';
 import { ProjectPermissionModel } from './models/project.model';
 import { StudyPermissionModel } from './models/study.model';
+import { Dataset } from '../dataset/dataset.model';
+import { DatasetService } from '../dataset/dataset.service';
+import { DatasetProjectPermission } from './models/dataset.model';
 
 @Injectable()
 export class PermissionService {
   constructor(
     @Inject(CASBIN_PROVIDER) private readonly enforcer: casbin.Enforcer,
-    private readonly userService: UserService
+    private readonly userService: UserService,
+    private readonly datasetService: DatasetService
   ) {}
 
   /** requestingUser must be an owner themselves */
@@ -163,4 +167,32 @@ export class PermissionService {
     }
     return true;
   }
+
+  async grantProjectDatasetAccess(project: Project, dataset: Dataset, hasAccess: boolean): Promise<boolean> {
+    if (hasAccess) {
+      await this.enforcer.addNamedGroupingPolicy('g2', project._id.toString(), dataset._id.toString());
+    } else {
+      await this.enforcer.removeNamedGroupingPolicy('g2', project._id.toString(), dataset._id.toString());
+    }
+    return true;
+  }
+
+  async getDatasetProjectPermissions(project: Project): Promise<DatasetProjectPermission[]> {
+    const datasets = await this.datasetService.findAll(project.organization);
+
+    return await Promise.all(
+      datasets.map(async (dataset) => {
+        const hasAccess = await this.enforcer.hasNamedGroupingPolicy(
+          'g2',
+          project._id.toString(),
+          dataset._id.toString()
+        );
+
+        return {
+          dataset: dataset._id.toString(),
+          projectHasAccess: hasAccess
+        };
+      })
+    );
+  }
 }
diff --git a/packages/server/src/permission/resolvers/dataset.resolver.ts b/packages/server/src/permission/resolvers/dataset.resolver.ts
new file mode 100644
index 00000000..b8ae39c3
--- /dev/null
+++ b/packages/server/src/permission/resolvers/dataset.resolver.ts
@@ -0,0 +1,60 @@
+import { ID, Mutation, Resolver, Args, Query, ResolveField, Parent } from '@nestjs/graphql';
+import { Inject, UseGuards, UnauthorizedException } from '@nestjs/common';
+import { JwtAuthGuard } from '../../jwt/jwt.guard';
+import { CASBIN_PROVIDER } from '../casbin.provider';
+import * as casbin from 'casbin';
+import { PermissionService } from '../permission.service';
+import { ProjectPipe } from '../../project/pipes/project.pipe';
+import { Project } from '../../project/project.model';
+import { DatasetPipe } from '../../dataset/pipes/dataset.pipe';
+import { Dataset } from '../../dataset/dataset.model';
+import { TokenContext } from '../../jwt/token.context';
+import { TokenPayload } from '../../jwt/token.dto';
+import { DatasetPermissions } from '../permissions/dataset';
+import { DatasetProjectPermission } from '../models/dataset.model';
+import { DatasetService } from '../../dataset/dataset.service';
+
+@UseGuards(JwtAuthGuard)
+@Resolver(() => DatasetProjectPermission)
+export class DatasetPermissionResolver {
+  constructor(
+    @Inject(CASBIN_PROVIDER) private readonly enforcer: casbin.Enforcer,
+    private readonly permissionService: PermissionService,
+    private readonly datasetService: DatasetService
+  ) {}
+
+  @Mutation(() => Boolean)
+  async grantProjectDatasetAccess(
+    @Args('project', { type: () => ID }, ProjectPipe) project: Project,
+    @Args('dataset', { type: () => ID }, DatasetPipe) dataset: Dataset,
+    @Args('hasAccess') hasAccess: boolean,
+    @TokenContext() requestingUser: TokenPayload
+  ) {
+    // Make sure the requesting user has access
+    const hasPermission = await this.enforcer.enforce(requestingUser.id, DatasetPermissions.GRANT_ACCESS, dataset._id);
+    if (!hasPermission) {
+      throw new UnauthorizedException('Requesting user does not have permission to manage dataset permissions');
+    }
+
+    return this.permissionService.grantProjectDatasetAccess(project, dataset, hasAccess);
+  }
+
+  @Query(() => [DatasetProjectPermission])
+  async getDatasetProjectPermissions(
+    @Args('project', { type: () => ID }, ProjectPipe) project: Project,
+    @TokenContext() requestingUser: TokenPayload
+  ) {
+    // Make sure the requesting user has access
+    const hasPermission = await this.enforcer.enforce(requestingUser.id, DatasetPermissions.GRANT_ACCESS, project._id);
+    if (!hasPermission) {
+      throw new UnauthorizedException('Requesting user does not have permission to manage dataset permissions');
+    }
+
+    return this.permissionService.getDatasetProjectPermissions(project);
+  }
+
+  @ResolveField(() => Dataset)
+  async dataset(@Parent() datasetProjectPermission: DatasetProjectPermission) {
+    return this.datasetService.findById(datasetProjectPermission.dataset);
+  }
+}