diff --git a/internal/proxydatasource/datasource_test.go b/internal/proxydatasource/datasource_test.go
index fb17c9d..e1d2c00 100644
--- a/internal/proxydatasource/datasource_test.go
+++ b/internal/proxydatasource/datasource_test.go
@@ -8,7 +8,6 @@
 	"context"
 	"errors"
 	"fmt"
-	"sort"
 	"strings"
 	"testing"
 	"time"
@@ -118,60 +117,6 @@
 	}, sample.LicenseCmpOpts...)
 )
 
-func TestDataSource_LegacyGetDirectory(t *testing.T) {
-	ctx, ds, teardown := setup(t)
-	defer teardown()
-	want := &internal.LegacyDirectory{
-		LegacyModuleInfo: internal.LegacyModuleInfo{ModuleInfo: wantModuleInfo},
-		Path:             "foo.com/bar",
-		Packages:         []*internal.LegacyPackage{&wantPackage},
-	}
-	got, err := ds.LegacyGetDirectory(ctx, "foo.com/bar", internal.UnknownModulePath, "v1.2.0", internal.AllFields)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if diff := cmp.Diff(want, got, cmpOpts...); diff != "" {
-		t.Errorf("LegacyGetDirectory diff (-want +got):\n%s", diff)
-	}
-}
-
-func TestDataSource_LegacyGetImports(t *testing.T) {
-	ctx, ds, teardown := setup(t)
-	defer teardown()
-	want := []string{"net/http"}
-	got, err := ds.LegacyGetImports(ctx, "foo.com/bar/baz", "foo.com/bar", "v1.2.0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if diff := cmp.Diff(want, got, cmpOpts...); diff != "" {
-		t.Errorf("LegacyGetImports diff (-want +got):\n%s", diff)
-	}
-}
-
-func TestDataSource_GetPackage_Latest(t *testing.T) {
-	ctx, ds, teardown := setup(t)
-	defer teardown()
-	got, err := ds.LegacyGetPackage(ctx, "foo.com/bar/baz", internal.UnknownModulePath, internal.LatestVersion)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if diff := cmp.Diff(wantVersionedPackage, got, cmpOpts...); diff != "" {
-		t.Errorf("GetLatestPackage diff (-want +got):\n%s", diff)
-	}
-}
-
-func TestDataSource_LegacyGetModuleInfo_Latest(t *testing.T) {
-	ctx, ds, teardown := setup(t)
-	defer teardown()
-	got, err := ds.LegacyGetModuleInfo(ctx, "foo.com/bar", internal.LatestVersion)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if diff := cmp.Diff(wantModuleInfo, got.ModuleInfo, cmpOpts...); diff != "" {
-		t.Errorf("GetLatestModuleInfo diff (-want +got):\n%s", diff)
-	}
-}
-
 func TestDataSource_GetModuleInfo(t *testing.T) {
 	ctx, ds, teardown := setup(t)
 	defer teardown()
@@ -184,174 +129,6 @@
 	}
 }
 
-func TestDataSource_LegacyGetLicenses(t *testing.T) {
-	t.Helper()
-	testModules := []*proxy.Module{
-		{
-			ModulePath: "foo.com/bar",
-			Version:    "v1.1.0",
-			Files: map[string]string{
-				"go.mod":  "module foo.com/bar",
-				"LICENSE": testhelper.MITLicense,
-				"bar.go":  "//Package bar provides a helpful constant.\npackage bar\nimport \"net/http\"\nconst OK = http.StatusOK",
-
-				"baz/baz.go": "//Package baz provides a helpful constant.\npackage baz\nimport \"net/http\"\nconst OK = http.StatusOK",
-
-				"qux/LICENSE": testhelper.BSD0License,
-				"qux/qux.go":  "//Package qux provides a helpful constant.\npackage qux\nimport \"net/http\"\nconst OK = http.StatusOK",
-			},
-		},
-	}
-	client, teardownProxy := proxy.SetupTestClient(t, testModules)
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	ds := New(client)
-	teardown := func() {
-		teardownProxy()
-		cancel()
-	}
-	defer teardown()
-
-	tests := []struct {
-		err        error
-		name       string
-		fullPath   string
-		modulePath string
-		want       []*licenses.License
-	}{
-		{name: "no license dir", fullPath: "foo.com", modulePath: "foo.com/bar", err: derrors.NotFound},
-		{name: "invalid dir", fullPath: "foo.com/invalid", modulePath: "foo.com/invalid", err: derrors.NotFound},
-		{name: "root dir", fullPath: "foo.com/bar", modulePath: "foo.com/bar", want: []*licenses.License{wantLicenseMIT}},
-		{name: "package with no extra license", fullPath: "foo.com/bar/baz", modulePath: "foo.com/bar", want: []*licenses.License{wantLicenseMIT}},
-		{name: "package with additional license", fullPath: "foo.com/bar/qux", modulePath: "foo.com/bar", want: []*licenses.License{wantLicenseMIT, wantLicenseBSD}},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			got, err := ds.LegacyGetLicenses(ctx, test.fullPath, test.modulePath, "v1.1.0")
-			if !errors.Is(err, test.err) {
-				t.Fatal(err)
-			}
-
-			sort.Slice(got, func(i, j int) bool {
-				return got[i].FilePath < got[j].FilePath
-			})
-			sort.Slice(test.want, func(i, j int) bool {
-				return test.want[i].FilePath < test.want[j].FilePath
-			})
-
-			if diff := cmp.Diff(test.want, got); diff != "" {
-				t.Errorf("LegacyGetLicenses diff (-want +got):\n%s", diff)
-			}
-		})
-	}
-}
-
-func TestDataSource_LegacyGetModuleLicenses(t *testing.T) {
-	ctx, ds, teardown := setup(t)
-	defer teardown()
-	got, err := ds.LegacyGetModuleLicenses(ctx, "foo.com/bar", "v1.2.0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	want := []*licenses.License{wantLicense}
-	if diff := cmp.Diff(want, got, cmpOpts...); diff != "" {
-		t.Errorf("LegacyGetModuleLicenses diff (-want +got):\n%s", diff)
-	}
-}
-
-func TestDataSource_LegacyGetPackage(t *testing.T) {
-	ctx, ds, teardown := setup(t)
-	defer teardown()
-	got, err := ds.LegacyGetPackage(ctx, "foo.com/bar/baz", internal.UnknownModulePath, "v1.2.0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if diff := cmp.Diff(wantVersionedPackage, got, cmpOpts...); diff != "" {
-		t.Errorf("GetPackage diff (-want +got):\n%s", diff)
-	}
-}
-
-func TestDataSource_LegacyGetPackageLicenses(t *testing.T) {
-	ctx, ds, teardown := setup(t)
-	defer teardown()
-	got, err := ds.LegacyGetPackageLicenses(ctx, "foo.com/bar/baz", "foo.com/bar", "v1.2.0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	want := []*licenses.License{wantLicense}
-	if diff := cmp.Diff(want, got, cmpOpts...); diff != "" {
-		t.Errorf("LegacyGetPackageLicenses diff (-want +got):\n%s", diff)
-	}
-}
-
-func TestDataSource_GetPackagesInVersion(t *testing.T) {
-	ctx, ds, teardown := setup(t)
-	defer teardown()
-	got, err := ds.LegacyGetPackagesInModule(ctx, "foo.com/bar", "v1.2.0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	want := []*internal.LegacyPackage{&wantPackage}
-	if diff := cmp.Diff(want, got, cmpOpts...); diff != "" {
-		t.Errorf("GetPackagesInVersion diff (-want +got):\n%s", diff)
-	}
-}
-
-func TestDataSource_LegacyGetTaggedVersionsForModule(t *testing.T) {
-	ctx, ds, teardown := setup(t)
-	defer teardown()
-	got, err := ds.LegacyGetTaggedVersionsForModule(ctx, "foo.com/bar")
-	if err != nil {
-		t.Fatal(err)
-	}
-	v110 := wantModuleInfo
-	v110.Version = "v1.1.0"
-	want := []*internal.ModuleInfo{
-		&wantModuleInfo,
-		&v110,
-	}
-	ignore := cmpopts.IgnoreFields(internal.ModuleInfo{}, "CommitTime", "IsRedistributable", "HasGoMod")
-	if diff := cmp.Diff(want, got, ignore); diff != "" {
-		t.Errorf("LegacyGetTaggedVersionsForPackageSeries diff (-want +got):\n%s", diff)
-	}
-}
-
-func TestDataSource_LegacyGetTaggedVersionsForPackageSeries(t *testing.T) {
-	ctx, ds, teardown := setup(t)
-	defer teardown()
-	// // TODO (rFindley): this shouldn't be necessary.
-	// _, err := ds.GetLatestPackage(ctx, "foo.com/bar/baz")
-	// if err != nil {
-	// 	t.Fatal(err)
-	// }
-	got, err := ds.LegacyGetTaggedVersionsForPackageSeries(ctx, "foo.com/bar/baz")
-	if err != nil {
-		t.Fatal(err)
-	}
-	v110 := wantModuleInfo
-	v110.Version = "v1.1.0"
-	want := []*internal.ModuleInfo{
-		&wantModuleInfo,
-		&v110,
-	}
-	ignore := cmpopts.IgnoreFields(internal.ModuleInfo{}, "CommitTime", "IsRedistributable", "HasGoMod")
-	if diff := cmp.Diff(want, got, ignore); diff != "" {
-		t.Errorf("LegacyGetTaggedVersionsForPackageSeries diff (-want +got):\n%s", diff)
-	}
-}
-
-func TestDataSource_LegacyGetModuleInfo(t *testing.T) {
-	ctx, ds, teardown := setup(t)
-	defer teardown()
-	got, err := ds.LegacyGetModuleInfo(ctx, "foo.com/bar", "v1.2.0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if diff := cmp.Diff(wantModuleInfo, got.ModuleInfo, cmpOpts...); diff != "" {
-		t.Errorf("LegacyGetModuleInfo diff (-want +got):\n%s", diff)
-	}
-}
-
 func TestDataSource_GetUnitMeta(t *testing.T) {
 	ctx, ds, teardown := setup(t)
 	defer teardown()
diff --git a/internal/proxydatasource/details.go b/internal/proxydatasource/details.go
index b7edde8..37da084 100644
--- a/internal/proxydatasource/details.go
+++ b/internal/proxydatasource/details.go
@@ -8,13 +8,9 @@
 
 import (
 	"context"
-	"fmt"
-	"path"
-	"strings"
 
 	"golang.org/x/pkgsite/internal"
 	"golang.org/x/pkgsite/internal/derrors"
-	"golang.org/x/pkgsite/internal/licenses"
 	"golang.org/x/pkgsite/internal/proxy"
 )
 
@@ -24,33 +20,6 @@
 	return ds.getUnit(ctx, um.Path, um.ModulePath, um.Version)
 }
 
-// LegacyGetLicenses return licenses at path for the given module path and version.
-func (ds *DataSource) LegacyGetLicenses(ctx context.Context, fullPath, modulePath, resolvedVersion string) (_ []*licenses.License, err error) {
-	defer derrors.Wrap(&err, "LegacyGetLicenses(%q, %q, %q)", fullPath, modulePath, resolvedVersion)
-	v, err := ds.getModule(ctx, modulePath, resolvedVersion)
-	if err != nil {
-		return nil, err
-	}
-
-	var lics []*licenses.License
-
-	// ds.getModule() returns all licenses for the module version. We need to
-	// filter the licenses that applies to the specified fullPath, i.e.
-	// A license in the current or any parent directory of the specified
-	// fullPath applies to it.
-	for _, license := range v.Licenses {
-		licensePath := path.Join(modulePath, path.Dir(license.FilePath))
-		if strings.HasPrefix(fullPath, licensePath) {
-			lics = append(lics, license)
-		}
-	}
-
-	if len(lics) == 0 {
-		return nil, fmt.Errorf("path %s is missing from module %s: %w", fullPath, modulePath, derrors.NotFound)
-	}
-	return lics, nil
-}
-
 // GetModuleInfo returns the ModuleInfo as fetched from the proxy for module
 // version specified by modulePath and version.
 func (ds *DataSource) GetModuleInfo(ctx context.Context, modulePath, version string) (_ *internal.ModuleInfo, err error) {
diff --git a/internal/proxydatasource/legacy_datasource.go b/internal/proxydatasource/legacy_datasource.go
deleted file mode 100644
index bc60ac1..0000000
--- a/internal/proxydatasource/legacy_datasource.go
+++ /dev/null
@@ -1,164 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package proxydatasource implements an internal.DataSource backed solely by a
-// proxy instance.
-package proxydatasource
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"golang.org/x/pkgsite/internal"
-	"golang.org/x/pkgsite/internal/derrors"
-	"golang.org/x/pkgsite/internal/licenses"
-	"golang.org/x/pkgsite/internal/proxy"
-)
-
-// LegacyGetDirectory returns packages contained in the given subdirectory of a module version.
-func (ds *DataSource) LegacyGetDirectory(ctx context.Context, dirPath, modulePath, version string, _ internal.FieldSet) (_ *internal.LegacyDirectory, err error) {
-	defer derrors.Wrap(&err, "LegacyGetDirectory(%q, %q, %q)", dirPath, modulePath, version)
-
-	var info *proxy.VersionInfo
-	if modulePath == internal.UnknownModulePath {
-		modulePath, info, err = ds.findModule(ctx, dirPath, version)
-		if err != nil {
-			return nil, err
-		}
-		version = info.Version
-	}
-	v, err := ds.getModule(ctx, modulePath, version)
-	if err != nil {
-		return nil, err
-	}
-	return &internal.LegacyDirectory{
-		LegacyModuleInfo: internal.LegacyModuleInfo{ModuleInfo: v.ModuleInfo},
-		Path:             dirPath,
-		Packages:         v.LegacyPackages,
-	}, nil
-}
-
-// LegacyGetModuleLicenses returns root-level licenses detected within the module zip
-// for modulePath and version.
-func (ds *DataSource) LegacyGetModuleLicenses(ctx context.Context, modulePath, version string) (_ []*licenses.License, err error) {
-	defer derrors.Wrap(&err, "LegacyGetModuleLicenses(%q, %q)", modulePath, version)
-	v, err := ds.getModule(ctx, modulePath, version)
-	if err != nil {
-		return nil, err
-	}
-	var filtered []*licenses.License
-	for _, lic := range v.Licenses {
-		if !strings.Contains(lic.FilePath, "/") {
-			filtered = append(filtered, lic)
-		}
-	}
-	return filtered, nil
-}
-
-// LegacyGetPackage returns a LegacyVersionedPackage for the given pkgPath and version. If
-// such a package exists in the cache, it will be returned without querying the
-// proxy. Otherwise, the proxy is queried to find the longest module path at
-// that version containing the package.
-func (ds *DataSource) LegacyGetPackage(ctx context.Context, pkgPath, modulePath, version string) (_ *internal.LegacyVersionedPackage, err error) {
-	defer derrors.Wrap(&err, "LegacyGetPackage(%q, %q)", pkgPath, version)
-
-	var m *internal.Module
-	if modulePath != internal.UnknownModulePath {
-		m, err = ds.getModule(ctx, modulePath, version)
-	} else {
-		m, err = ds.getPackageVersion(ctx, pkgPath, version)
-	}
-	if err != nil {
-		return nil, err
-	}
-	return packageFromVersion(pkgPath, m)
-}
-
-// LegacyGetPackageLicenses returns the Licenses that apply to pkgPath within the
-// module version specified by modulePath and version.
-func (ds *DataSource) LegacyGetPackageLicenses(ctx context.Context, pkgPath, modulePath, version string) (_ []*licenses.License, err error) {
-	defer derrors.Wrap(&err, "LegacyGetPackageLicenses(%q, %q, %q)", pkgPath, modulePath, version)
-	v, err := ds.getModule(ctx, modulePath, version)
-	if err != nil {
-		return nil, err
-	}
-	for _, p := range v.LegacyPackages {
-		if p.Path == pkgPath {
-			var lics []*licenses.License
-			for _, lmd := range p.Licenses {
-				// lmd is just license metadata, the version has the actual licenses.
-				for _, lic := range v.Licenses {
-					if lic.FilePath == lmd.FilePath {
-						lics = append(lics, lic)
-						break
-					}
-				}
-			}
-			return lics, nil
-		}
-	}
-	return nil, fmt.Errorf("package %s is missing from module %s: %w", pkgPath, modulePath, derrors.NotFound)
-}
-
-// LegacyGetPackagesInModule returns LegacyPackages contained in the module zip corresponding to modulePath and version.
-func (ds *DataSource) LegacyGetPackagesInModule(ctx context.Context, modulePath, version string) (_ []*internal.LegacyPackage, err error) {
-	defer derrors.Wrap(&err, "LegacyGetPackagesInModule(%q, %q)", modulePath, version)
-	v, err := ds.getModule(ctx, modulePath, version)
-	if err != nil {
-		return nil, err
-	}
-	return v.LegacyPackages, nil
-}
-
-// LegacyGetPsuedoVersionsForModule returns versions from the the proxy /list
-// endpoint, if they are pseudoversions. Otherwise, it returns an empty slice.
-func (ds *DataSource) LegacyGetPsuedoVersionsForModule(ctx context.Context, modulePath string) (_ []*internal.ModuleInfo, err error) {
-	defer derrors.Wrap(&err, "LegacyGetPsuedoVersionsForModule(%q)", modulePath)
-	return ds.listModuleVersions(ctx, modulePath, true)
-}
-
-// LegacyGetPsuedoVersionsForPackageSeries finds the longest module path containing
-// pkgPath, and returns its versions from the proxy /list endpoint, if they are
-// pseudoversions. Otherwise, it returns an empty slice.
-func (ds *DataSource) LegacyGetPsuedoVersionsForPackageSeries(ctx context.Context, pkgPath string) (_ []*internal.ModuleInfo, err error) {
-	defer derrors.Wrap(&err, "LegacyGetPsuedoVersionsForPackageSeries(%q)", pkgPath)
-	return ds.listPackageVersions(ctx, pkgPath, true)
-}
-
-// LegacyGetTaggedVersionsForModule returns versions from the the proxy /list
-// endpoint, if they are tagged versions. Otherwise, it returns an empty slice.
-func (ds *DataSource) LegacyGetTaggedVersionsForModule(ctx context.Context, modulePath string) (_ []*internal.ModuleInfo, err error) {
-	defer derrors.Wrap(&err, "LegacyGetTaggedVersionsForModule(%q)", modulePath)
-	return ds.listModuleVersions(ctx, modulePath, false)
-}
-
-// LegacyGetTaggedVersionsForPackageSeries finds the longest module path containing
-// pkgPath, and returns its versions from the proxy /list endpoint, if they are
-// tagged versions. Otherwise, it returns an empty slice.
-func (ds *DataSource) LegacyGetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) (_ []*internal.ModuleInfo, err error) {
-	defer derrors.Wrap(&err, "LegacyGetTaggedVersionsForPackageSeries(%q)", pkgPath)
-	return ds.listPackageVersions(ctx, pkgPath, false)
-}
-
-// LegacyGetModuleInfo returns the LegacyModuleInfo as fetched from the proxy for module
-// version specified by modulePath and version.
-func (ds *DataSource) LegacyGetModuleInfo(ctx context.Context, modulePath, version string) (_ *internal.LegacyModuleInfo, err error) {
-	defer derrors.Wrap(&err, "LegacyGetModuleInfo(%q, %q)", modulePath, version)
-	m, err := ds.getModule(ctx, modulePath, version)
-	if err != nil {
-		return nil, err
-	}
-	return &m.LegacyModuleInfo, nil
-}
-
-// LegacyGetImports returns package imports as extracted from the module zip.
-func (ds *DataSource) LegacyGetImports(ctx context.Context, pkgPath, modulePath, version string) (_ []string, err error) {
-	defer derrors.Wrap(&err, "LegacyGetImports(%q, %q, %q)", pkgPath, modulePath, version)
-	vp, err := ds.LegacyGetPackage(ctx, pkgPath, modulePath, version)
-	if err != nil {
-		return nil, err
-	}
-	return vp.Imports, nil
-}