Problem Description #

I want to extract the foo part from the URL https://github.com/foo/bar and fetch all repositories belonging to foo. Right now, I first try to fetch foo as an organization — if that succeeds, I get its repos; if it returns a 404 error (using Promises), I assume it's a user and fetch user repos instead. But this approach is inefficient and prone to hitting GitHub's rate limits. Is there a better way to tell if foo is a user or an organization?

Answer #

Great question — that trial-and-error approach definitely isn't ideal. Here's a much cleaner, more efficient way to handle this:

Use the GitHub GET /users/{username} API endpoint #

GitHub's API has a dedicated endpoint that tells you exactly what type of entity you're dealing with. When you call GET /users/{username} (or the corresponding SDK method, like Octokit's api.users.get({ username: 'foo' })), the response includes a type field with a value of either User or Organization. This lets you make a single API call to determine the entity type, then branch your logic accordingly.

Here's a quick example using Octokit:

async function getEntityType(username) {
  try {
    const { data } = await api.users.get({ username });
    return data.type; // Will return "User" or "Organization"
  } catch (err) {
    // Handle cases where the entity doesn't exist
    console.error(`Entity "${username}" not found:`, err);
    return null;
  }
}

async function fetchAllRepos(username) {
  const entityType = await getEntityType(username);
  
  if (entityType === 'Organization') {
    return await api.repos.getForOrg({ org: username });
  } else if (entityType === 'User') {
    return await api.repos.getForUser({ username });
  } else {
    throw new Error(`Could not determine type for entity "${username}"`);
  }
}

Why this is better than your current approach: #

• Fewer API calls: Only one request to determine the type, instead of potentially two. This cuts down on latency and reduces your API usage.
• Lower rate limit risk: Less API traffic means you're less likely to hit GitHub's rate limits, which is especially important if you're processing multiple entities.
• More reliable: No chance of misinterpreting non-404 errors (like temporary server issues) as a "user not found" scenario. The type field gives you a definitive answer.

One extra note: If you're using a newer version of Octokit, you can also use rest.repos.listForUser and rest.repos.listForOrg directly once you know the type — the core logic remains the same: validate the entity type first with a single call, then fetch the repos.

内容的提问来源于stack exchange，提问作者Traveling Tech Guy