Compare Common Core and state frameworks

Use Knowledge Graph’s U.S. academic standards crosswalks to compare and state frameworks’ standards. Standards crosswalks interpret how closely 2 standards’ Learning Components align.

Diagram: state mathematics standards linked to Common Core standards via
hasStandardAlignment, with Jaccard similarity and shared Learning
Components

Diagram description

The diagram shows the U.S. academic standards crosswalks dataset only: state mathematics standards mapped to Common Core State Standards. Both endpoints are StandardsFrameworkItem (defined in Standards). Direction is always state → CCSS, not between states. Edge properties include jaccard and LC counts; see hasStandardAlignment.Example (New York → CCSS): A state standard is a StandardsFrameworkItem from a state framework—e.g. NY 3.NF.1 (Understand a fraction 1/b as the quantity formed by 1 part when a whole is partitioned into b equal parts). A CCSS standard is a StandardsFrameworkItem from Common Core Math—e.g. 3.NF.A.1. A hasStandardAlignment edge connects them when they share at least one Learning Component; the edge has properties such as jaccard (e.g. 0.85), stateLCCount, ccssLCCount, sharedLCCount. So: NY 3.NF.1 -[:hasStandardAlignment]-> 3.NF.A.1. Crosswalks are only state → CCSS (never state → state).Edge list (source → relationship → target):

StandardsFrameworkItem (state) → hasStandardAlignment → StandardsFrameworkItem (CCSS) (e.g. NY 3.NF.1 → 3.NF.A.1)

What you’ll do

Identify the closest Texas standards for a given CCSSM standard
Interpret alignment strength using Jaccard scores and LC counts
Inspect the shared Learning Components that support each alignment

What you’ll need

API key and base URL in the Learning Commons Platform ↗
Familiarity with the GET /academic-standards/search, GET /academic-standards/{uuid}/crosswalks, and GET /academic-standards/{uuid}/learning-components API endpoints
curl ↗, Python, or Node

Steps

Set up environment variables

.env

API_KEY=your_api_key_here
BASE_URL=https://api.learningcommons.org/knowledge-graph/v0

Find the Texas standards that best match the 6.EE.B.5 CCSSM standard

First, use GET /academic-standards/search to find the 6.EE.B.5 CCSSM standard.Then, use GET /academic-standards/{uuid}/crosswalks to get Texas standards that share Learning Components with that CCSSM standard.

curl -X GET \
  -H "x-api-key: YOUR_API_KEY" \
  "https://api.learningcommons.org/knowledge-graph/v0/academic-standards/search?statementCode=6.EE.B.5&jurisdiction=Multi-State"

import os
import requests

api_key = os.getenv("API_KEY")
base_url = os.getenv("BASE_URL")

TARGET_CCSSM_STANDARD_CODE = "6.EE.B.5"
TARGET_CCSSM_JURISDICTION = "Multi-State"

headers = {"x-api-key": api_key}

# Find the CCSSM standard by its statement code and jurisdiction
search_response = requests.get(
    f"{base_url}/academic-standards/search",
    headers=headers,
    params={
        "statementCode": TARGET_CCSSM_STANDARD_CODE,
        "jurisdiction": TARGET_CCSSM_JURISDICTION
    }
)

search_result = search_response.json()
ccssm_standard = search_result[0] if search_result else None

if not ccssm_standard:
    print(f'❌ CCSSM standard not found: {TARGET_CCSSM_STANDARD_CODE}')
else:
    ccssm_standard_uuid = ccssm_standard['caseIdentifierUUID']
    print(f'✅ Found CCSSM standard: {TARGET_CCSSM_STANDARD_CODE}')
    print(f'  Case UUID: {ccssm_standard_uuid}')
    print(f'  Description: {ccssm_standard["description"]}')

const apiKey = process.env.API_KEY;
const baseUrl = process.env.BASE_URL;

const TARGET_CCSSM_STANDARD_CODE = "6.EE.B.5";
const TARGET_CCSSM_JURISDICTION = "Multi-State";

// Find the CCSSM standard by its statement code and jurisdiction
const searchResponse = await fetch(
  `${baseUrl}/academic-standards/search?statementCode=${TARGET_CCSSM_STANDARD_CODE}&jurisdiction=${TARGET_CCSSM_JURISDICTION}`,
  {
    method: "GET",
    headers: { "x-api-key": apiKey },
  },
);

const searchResult = await searchResponse.json();
const ccssmStandard = searchResult[0] || null;

if (!ccssmStandard) {
  console.log(`❌ CCSSM standard not found: ${TARGET_CCSSM_STANDARD_CODE}`);
} else {
  const ccssmStandardUuid = ccssmStandard.caseIdentifierUUID;
  console.log(`✅ Found CCSSM standard: ${TARGET_CCSSM_STANDARD_CODE}`);
  console.log(`  Case UUID: ${ccssmStandardUuid}`);
  console.log(`  Description: ${ccssmStandard.description}`);
}

Response

{
  "caseIdentifierUUID": "6b9f74c0-d7cc-11e8-824f-0242ac160002",
  "statementCode": "6.EE.B.5",
  "description": "Understand solving an equation or inequality as a process of answering a question: which values from a specified set, if any, make the equation or inequality true? Use substitution to determine whether a given number in a specified set makes an equation or inequality true.",
  "jurisdiction": "Multi-State"
}

Use the GET /academic-standards/{caseIdentifierUUID}/crosswalks API endpoint with the caseIdentifierUUID from your response:

# Replace CCSSM_UUID with the caseIdentifierUUID from the previous step
curl -X GET \
  -H "x-api-key: YOUR_API_KEY" \
  "https://api.learningcommons.org/knowledge-graph/v0/academic-standards/6b9f74c0-d7cc-11e8-824f-0242ac160002/crosswalks?jurisdiction=Texas"

import os
import requests

api_key = os.getenv("API_KEY")
base_url = os.getenv("BASE_URL")

headers = {"x-api-key": api_key}

# ccssm_standard_uuid from previous step
crosswalk_response = requests.get(
    f"{base_url}/academic-standards/{ccssm_standard_uuid}/crosswalks",
    headers=headers,
    params={"jurisdiction": "Texas"}
)

crosswalk_result = crosswalk_response.json()
texas_matches = crosswalk_result["data"]

if not texas_matches:
    print(f'❌ No Texas standard matches found for {TARGET_CCSSM_STANDARD_CODE}')
else:
    # Sort by Jaccard score (highest first)
    texas_matches_sorted = sorted(texas_matches, key=lambda x: x['jaccard'], reverse=True)

    print(f'\n✅ Found {len(texas_matches_sorted)} Texas standard matches')
    print(f'\n📊 Top Texas match (highest Jaccard score):')

    top_match = texas_matches_sorted[0]
    print(f'  Statement Code: {top_match["statementCode"]}')
    print(f'  Jaccard Score: {top_match["jaccard"]:.4f}')
    print(f'  Shared LC Count: {top_match["sharedLCCount"]}')
    print(f'  State LC Count: {top_match["stateLCCount"]}')
    print(f'  CCSS LC Count: {top_match["ccssLCCount"]}')

const apiKey = process.env.API_KEY;
const baseUrl = process.env.BASE_URL;

// ccssmStandardUuid from previous step
const crosswalkResponse = await fetch(
  `${baseUrl}/academic-standards/${ccssmStandardUuid}/crosswalks?jurisdiction=Texas`,
  {
    method: "GET",
    headers: { "x-api-key": apiKey },
  },
);

const crosswalkResult = await crosswalkResponse.json();
let texasMatches = crosswalkResult.data;

if (!texasMatches || texasMatches.length === 0) {
  console.log(
    `❌ No Texas standard matches found for ${TARGET_CCSSM_STANDARD_CODE}`,
  );
} else {
  // Sort by Jaccard score (highest first)
  const texasMatchesSorted = texasMatches.sort((a, b) => b.jaccard - a.jaccard);

  console.log(`\n✅ Found ${texasMatchesSorted.length} Texas standard matches`);
  console.log(`\n📊 Top Texas match (highest Jaccard score):`);

  const topMatch = texasMatchesSorted[0];
  console.log(`  Statement Code: ${topMatch.statementCode}`);
  console.log(`  Jaccard Score: ${topMatch.jaccard.toFixed(4)}`);
  console.log(`  Shared LC Count: ${topMatch.sharedLCCount}`);
  console.log(`  State LC Count: ${topMatch.stateLCCount}`);
  console.log(`  CCSS LC Count: ${topMatch.ccssLCCount}`);
}

The response contains the Texas standards that share Learning Components with your target 6.EE.B.5 CCSSM standard, with overlap metrics:

Response

{
  "data": [
    {
      "caseIdentifierUUID": "18077fab-3aac-5dcc-89da-f8081e9045bd",
      "statementCode": "111.27.b.11.B",
      "description": "determine if the given value(s) make(s) one-variable, two-step equations and inequalities true; and",
      "jurisdiction": "Texas",
      "jaccard": 0.6667,
      "stateLCCount": 2,
      "ccssLCCount": 3,
      "sharedLCCount": 2
    },
    {
      "caseIdentifierUUID": "005fc52f-b920-506c-bea1-6857b886f6b6",
      "statementCode": "111.26.b.10.B",
      "description": "determine if the given value(s) make(s) one-variable, one-step equations or inequalities true.",
      "jurisdiction": "Texas",
      "jaccard": 0.2,
      "stateLCCount": 3,
      "ccssLCCount": 3,
      "sharedLCCount": 1
    }
  ]
}

A Jaccard score of 1.0 means the standards have identical Learning Components. An index of 0.0 indicates no overlap.A Jaccard score of 0.6 is a good starting point for identifying strong matches, but you can adjust this threshold based on your use case.

Interpret the relationship metrics

Each crosswalk relationship carries additional context about the degree of overlap:

sharedLCCount – Number of shared deconstructed skills
stateLCCount – Number of skills that support the state standard
ccssLCCount – Number of skills that support the CCSSM standard

With the Jaccard score, these counts help you interpret the strength and balance of the overlap (e.g. does one standard cover more ground than the other? Are their scopes comparable?).

Inspect shared Learning Components

Now that you have crosswalk pairs (CCSSM → Texas), retrieve the actual skills (i.e. Learning Components) that support each standard.

# Get Learning Components for CCSS standard
curl -X GET \
  -H "x-api-key: YOUR_API_KEY" \
  "https://api.learningcommons.org/knowledge-graph/v0/academic-standards/6b9f74c0-d7cc-11e8-824f-0242ac160002/learning-components"

# Get Learning Components for Texas standard (using the top match from the previous step)
curl -X GET \
  -H "x-api-key: YOUR_API_KEY" \
  "https://api.learningcommons.org/knowledge-graph/v0/academic-standards/18077fab-3aac-5dcc-89da-f8081e9045bd/learning-components"

import os
import requests

api_key = os.getenv("API_KEY")
base_url = os.getenv("BASE_URL")

headers = {"x-api-key": api_key}

# Use the top match from the previous step
top_match = texas_matches_sorted[0]
state_standard_uuid = top_match['caseIdentifierUUID']

# Get LCs that support the CCSS standard
ccss_lc_response = requests.get(
    f"{base_url}/academic-standards/{ccssm_standard_uuid}/learning-components",
    headers=headers
)
ccss_lc_result = ccss_lc_response.json()
ccss_lcs = ccss_lc_result["data"]

# Get LCs that support the state standard
state_lc_response = requests.get(
    f"{base_url}/academic-standards/{state_standard_uuid}/learning-components",
    headers=headers
)
state_lc_result = state_lc_response.json()
state_lcs = state_lc_result["data"]

# Create sets of LC identifiers for comparison
ccss_lc_ids = {lc['identifier'] for lc in ccss_lcs}
state_lc_ids = {lc['identifier'] for lc in state_lcs}

# Find shared and unique LCs
shared_lc_ids = ccss_lc_ids & state_lc_ids
ccss_only_ids = ccss_lc_ids - state_lc_ids
state_only_ids = state_lc_ids - ccss_lc_ids

# Get LC descriptions
shared_lcs = [lc for lc in ccss_lcs if lc['identifier'] in shared_lc_ids]
ccss_only_lcs = [lc for lc in ccss_lcs if lc['identifier'] in ccss_only_ids]
state_only_lcs = [lc for lc in state_lcs if lc['identifier'] in state_only_ids]

print(f'\n✅ LEARNING COMPONENTS ANALYSIS:')
print(f'CCSS Standard: {ccssm_standard["statementCode"]}')
print(f'State Standard: {top_match["statementCode"]}')
print()

print(f'📊 SHARED LEARNING COMPONENTS ({len(shared_lcs)}):')
for idx, lc in enumerate(shared_lcs, 1):
    print(f'  ✅ {idx}. {lc["description"]}')
print()

print(f'📊 CCSS-ONLY LEARNING COMPONENTS ({len(ccss_only_lcs)}):')
for idx, lc in enumerate(ccss_only_lcs, 1):
    print(f'  ➕ {idx}. {lc["description"]}')
print()

print(f'📊 STATE-ONLY LEARNING COMPONENTS ({len(state_only_lcs)}):')
for idx, lc in enumerate(state_only_lcs, 1):
    print(f'  ➖ {idx}. {lc["description"]}')

const apiKey = process.env.API_KEY;
const baseUrl = process.env.BASE_URL;

// Use the top match from the previous step
const topMatch = texasMatchesSorted[0];
const stateStandardUuid = topMatch.caseIdentifierUUID;

// Get LCs that support the CCSS standard
const ccssLcResponse = await fetch(
  `${baseUrl}/academic-standards/${ccssmStandardUuid}/learning-components`,
  {
    method: "GET",
    headers: { "x-api-key": apiKey },
  },
);
const ccssLcResult = await ccssLcResponse.json();
const ccssLcs = ccssLcResult.data;

// Get LCs that support the state standard
const stateLcResponse = await fetch(
  `${baseUrl}/academic-standards/${stateStandardUuid}/learning-components`,
  {
    method: "GET",
    headers: { "x-api-key": apiKey },
  },
);
const stateLcResult = await stateLcResponse.json();
const stateLcs = stateLcResult.data;

// Create sets of LC identifiers for comparison
const ccssLcIds = new Set(ccssLcs.map((lc) => lc.identifier));
const stateLcIds = new Set(stateLcs.map((lc) => lc.identifier));

// Find shared and unique LCs
const sharedLcIds = new Set([...ccssLcIds].filter((id) => stateLcIds.has(id)));
const ccssOnlyIds = new Set([...ccssLcIds].filter((id) => !stateLcIds.has(id)));
const stateOnlyIds = new Set(
  [...stateLcIds].filter((id) => !ccssLcIds.has(id)),
);

// Get LC descriptions
const sharedLcs = ccssLcs.filter((lc) => sharedLcIds.has(lc.identifier));
const ccssOnlyLcs = ccssLcs.filter((lc) => ccssOnlyIds.has(lc.identifier));
const stateOnlyLcs = stateLcs.filter((lc) => stateOnlyIds.has(lc.identifier));

console.log(`\n✅ LEARNING COMPONENTS ANALYSIS:`);
console.log(`CCSS Standard: ${ccssmStandard.statementCode}`);
console.log(`State Standard: ${topMatch.statementCode}`);
console.log();

console.log(`📊 SHARED LEARNING COMPONENTS (${sharedLcs.length}):`);
sharedLcs.forEach((lc, idx) => {
  console.log(`  ✅ ${idx + 1}. ${lc.description}`);
});
console.log();

console.log(`📊 CCSS-ONLY LEARNING COMPONENTS (${ccssOnlyLcs.length}):`);
ccssOnlyLcs.forEach((lc, idx) => {
  console.log(`  ➕ ${idx + 1}. ${lc.description}`);
});
console.log();

console.log(`📊 STATE-ONLY LEARNING COMPONENTS (${stateOnlyLcs.length}):`);
stateOnlyLcs.forEach((lc, idx) => {
  console.log(`  ➖ ${idx + 1}. ${lc.description}`);
});

This analysis reveals the Learning Components that are present in both standards, and the Learning Components that are unique to either the CCSS or state standard.

Keep exploring

Now that you understand which Learning Components are shared vs. unique, you can make informed decisions about how to adapt your content to align to curriculum standards.Explore other Standards crosswalks to compare other states’ standards to Common Core and to guide alignment work across frameworks in your own edtech product.

Use cases

Explore standards alignment, planning, crosswalks, curriculum, and assessment workflows.

Tutorial: Tag content to state standards

Query frameworks and standards in a step-by-step tutorial.

Tutorial: Generate practice questions

Use progressions to find prerequisites and generate practice content.

Understanding Knowledge Graph

Getting Started

Using Knowledge Graph

Datasets

Schema Reference

Resources

Compare Common Core and state frameworks

What you’ll do

What you’ll need

Steps

Use cases

Tutorial: Tag content to state standards

Tutorial: Generate practice questions

​What you’ll do

​What you’ll need

​Steps

​Related topics

Use cases

Tutorial: Tag content to state standards

Tutorial: Generate practice questions

What you’ll do

What you’ll need

Steps

Related topics