Connecting a Portfolio

After you populate your Nukleio account with profile data, projects, files, and an API key, you can connect a portfolio website to the public API.

A connected portfolio requests your public Nukleio data, then renders that data using your own design.

Before You Connect

Make sure you have completed these steps in Nukleio:

profile information added
at least one project added
files or images uploaded if your portfolio needs them
API key created
API key copied and stored securely

You can connect earlier for testing, but having real content makes it easier to confirm that your portfolio is rendering data correctly.

How the Integration Works

Your portfolio sends a request to Nukleio’s public API using your API key.


GET /api/public/getUserData
Authorization: Bearer YOUR_API_KEY

Nukleio validates the key and returns your public portfolio data as JSON. Your frontend then maps that JSON into portfolio sections such as your hero, bio, project list, links, and file downloads.

Where to Store the API Key

Store your API key in an environment variable when possible.

Example:


NUKLEIO_API_KEY=your_api_key_here

Avoid placing the key directly inside reusable components or committing it to a public repository.

If your portfolio fetches data from server-side code, keep the key server-side. If your portfolio must fetch directly from the browser, understand that the key may be visible to visitors through browser developer tools.

Request Shape

Your integration should send the API key as a bearer token:


Authorization: Bearer YOUR_API_KEY

Below are some common languages and frameworks querying from the Nukleio public API:

fetch


const response = await fetch("https://www.nukleio.com/api/public/getUserData", {
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
  },
});
 
const data = await response.json();
console.log(data);

Axios


import axios from "axios";
 
const { data } = await axios.get(
  "https://www.nukleio.com/api/public/getUserData",
  {
    headers: {
      Authorization: "Bearer YOUR_API_KEY",
    },
  }
);
 
console.log(data);

cURL


curl https://www.nukleio.com/api/public/getUserData \
  -H "Authorization: Bearer YOUR_API_KEY"

HTTP


GET /api/public/getUserData HTTP/1.1
Host: nukleio.com
Authorization: Bearer YOUR_API_KEY

Python

Python (requests)


import requests
 
response = requests.get(
    "https://www.nukleio.com/api/public/getUserData",
    headers={
        "Authorization": "Bearer YOUR_API_KEY"
    }
)
 
print(response.json())

C#

C# (.NET)


using System.Net.Http.Headers;
 
using var client = new HttpClient();
 
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", "YOUR_API_KEY");
 
var response = await client.GetAsync(
    "https://www.nukleio.com/api/public/getUserData"
);
 
var json = await response.Content.ReadAsStringAsync();
 
Console.WriteLine(json);

Go


package main
 
import (
    "fmt"
    "io"
    "net/http"
)
 
func main() {
    req, _ := http.NewRequest(
        "GET",
        "https://www.nukleio.com/api/public/getUserData",
        nil,
    )
 
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
 
    client := &http.Client{}
    res, _ := client.Do(req)
    defer res.Body.Close()
 
    body, _ := io.ReadAll(res.Body)
 
    fmt.Println(string(body))
}

PHP


<?php
 
$ch = curl_init("https://www.nukleio.com/api/public/getUserData");
 
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer YOUR_API_KEY"
]);
 
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 
$response = curl_exec($ch);
 
curl_close($ch);
 
echo $response;

Response Schema

The public API returns a JSON object containing the user’s portfolio data under the userInfo property.

response-schema.json


{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "Nukleio User Data Response",
  "description": "The response returned by the Nukleio public user data API.",
  "type": "object",
  "additionalProperties": false,
  "required": ["userInfo"],
  "properties": {
    "userInfo": {
      "$ref": "#/$defs/UserData"
    }
  },
  "$defs": {
    "UserData": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "name",
        "email",
        "skills",
        "experiences",
        "projects",
        "education"
      ],
      "properties": {
        "id": {
          "type": "string",
          "format": "uuid",
          "description": "The unique identifier for the user."
        },
        "name": {
          "type": ["string", "null"],
          "description": "The user's full name."
        },
        "phone_number": {
          "type": ["string", "null"],
          "description": "The user's phone number."
        },
        "email": {
          "type": "string",
          "format": "email",
          "description": "The user's public email address."
        },
        "location": {
          "type": ["string", "null"],
          "description": "The user's general location."
        },
        "current_address": {
          "type": ["string", "null"],
          "description": "The user's current address."
        },
        "current_company": {
          "type": ["string", "null"],
          "description": "The user's current employer."
        },
        "current_position": {
          "type": ["string", "null"],
          "description": "The user's current position or job title."
        },
        "github_url": {
          "type": ["string", "null"],
          "format": "uri",
          "description": "A link to the user's GitHub profile."
        },
        "linkedin_url": {
          "type": ["string", "null"],
          "format": "uri",
          "description": "A link to the user's LinkedIn profile."
        },
        "instagram_url": {
          "type": ["string", "null"],
          "format": "uri",
          "description": "A link to the user's Instagram profile."
        },
        "facebook_url": {
          "type": ["string", "null"],
          "format": "uri",
          "description": "A link to the user's Facebook profile."
        },
        "x_url": {
          "type": ["string", "null"],
          "description": "A link to the user's X profile. An empty string may be returned when no URL is configured."
        },
        "portrait_url": {
          "type": ["string", "null"],
          "format": "uri",
          "description": "A URL for the user's portrait or profile image."
        },
        "resume_url": {
          "type": ["string", "null"],
          "format": "uri",
          "description": "A URL for the user's resume."
        },
        "transcript_url": {
          "type": ["string", "null"],
          "format": "uri",
          "description": "A URL for the user's academic transcript."
        },
        "bio": {
          "type": ["string", "null"],
          "description": "The user's biography or professional summary."
        },
        "skills": {
          "type": "array",
          "description": "The user's technical and professional skills.",
          "items": {
            "$ref": "#/$defs/UserSkill"
          }
        },
        "experiences": {
          "type": "array",
          "description": "The user's professional experience.",
          "items": {
            "$ref": "#/$defs/UserExperience"
          }
        },
        "projects": {
          "type": "array",
          "description": "The user's portfolio projects.",
          "items": {
            "$ref": "#/$defs/UserProject"
          }
        },
        "education": {
          "type": "array",
          "description": "The user's education history.",
          "items": {
            "$ref": "#/$defs/UserEducation"
          }
        },
        "subscription": {
          "oneOf": [
            {
              "$ref": "#/$defs/Subscription"
            },
            {
              "type": "null"
            }
          ],
          "description": "The user's Nukleio subscription information."
        }
      }
    },
    "UserSkill": {
      "type": "object",
      "additionalProperties": false,
      "required": ["name", "proficiency", "years_of_experience"],
      "properties": {
        "id": {
          "type": "string",
          "format": "uuid",
          "description": "The unique identifier for the skill."
        },
        "name": {
          "type": "string",
          "description": "The name of the skill."
        },
        "proficiency": {
          "type": ["number", "null"],
          "minimum": 0,
          "description": "The user's proficiency level for the skill."
        },
        "years_of_experience": {
          "type": ["number", "null"],
          "minimum": 0,
          "description": "The number of years the user has worked with the skill."
        }
      }
    },
    "UserExperience": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "company",
        "job_title",
        "date_start",
        "date_end",
        "job_description"
      ],
      "properties": {
        "id": {
          "type": "string",
          "format": "uuid",
          "description": "The unique identifier for the experience entry."
        },
        "company": {
          "type": "string",
          "description": "The employer or organization name."
        },
        "job_title": {
          "type": "string",
          "description": "The user's title or position."
        },
        "date_start": {
          "type": ["string", "null"],
          "format": "date",
          "description": "The date the position began."
        },
        "date_end": {
          "type": ["string", "null"],
          "format": "date",
          "description": "The date the position ended. Null indicates a current position."
        },
        "job_description": {
          "type": ["string", "null"],
          "description": "A description of the user's responsibilities and accomplishments."
        }
      }
    },
    "UserProject": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "id",
        "name",
        "date_start",
        "date_end",
        "languages_used",
        "frameworks_used",
        "technologies_used",
        "description",
        "github_url",
        "demo_url",
        "thumbnail_url"
      ],
      "properties": {
        "id": {
          "type": "string",
          "format": "uuid",
          "description": "The unique identifier for the project."
        },
        "name": {
          "type": "string",
          "description": "The project name."
        },
        "date_start": {
          "type": "string",
          "format": "date",
          "description": "The date work on the project began."
        },
        "date_end": {
          "type": "string",
          "format": "date",
          "description": "The date work on the project ended."
        },
        "languages_used": {
          "type": ["array", "null"],
          "description": "Programming languages used by the project.",
          "items": {
            "type": "string"
          }
        },
        "frameworks_used": {
          "type": ["array", "null"],
          "description": "Frameworks used by the project.",
          "items": {
            "type": "string"
          }
        },
        "technologies_used": {
          "type": ["array", "null"],
          "description": "Technologies, platforms, and services used by the project.",
          "items": {
            "type": "string"
          }
        },
        "description": {
          "type": "string",
          "description": "A description of the project."
        },
        "github_url": {
          "type": ["string", "null"],
          "format": "uri",
          "description": "A link to the project's source repository."
        },
        "demo_url": {
          "type": ["string", "null"],
          "format": "uri",
          "description": "A link to the project's live demo."
        },
        "thumbnail_url": {
          "type": ["string", "null"],
          "format": "uri",
          "description": "A URL for the project's thumbnail image."
        }
      }
    },
    "UserEducation": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "degree",
        "majors",
        "minors",
        "gpa",
        "institution",
        "awards",
        "year_start",
        "year_end",
        "courses"
      ],
      "properties": {
        "id": {
          "type": "string",
          "format": "uuid",
          "description": "The unique identifier for the education entry."
        },
        "degree": {
          "type": "string",
          "description": "The degree or qualification earned."
        },
        "majors": {
          "type": "array",
          "description": "The user's academic majors.",
          "items": {
            "type": "string"
          }
        },
        "minors": {
          "type": "array",
          "description": "The user's academic minors.",
          "items": {
            "type": "string"
          }
        },
        "gpa": {
          "type": ["number", "string", "null"],
          "description": "The user's grade point average. The API may currently return this value as a number or numeric string."
        },
        "institution": {
          "type": "string",
          "description": "The educational institution's name."
        },
        "awards": {
          "type": "array",
          "description": "Academic awards and honors.",
          "items": {
            "type": "string"
          }
        },
        "year_start": {
          "type": ["integer", "null"],
          "minimum": 0,
          "description": "The year the user began attending the institution."
        },
        "year_end": {
          "type": ["integer", "null"],
          "minimum": 0,
          "description": "The year the user completed or expects to complete the program."
        },
        "courses": {
          "type": "array",
          "description": "Courses completed at the institution.",
          "items": {
            "$ref": "#/$defs/Course"
          }
        }
      }
    },
    "Course": {
      "type": "object",
      "additionalProperties": false,
      "required": ["name", "grade", "description"],
      "properties": {
        "id": {
          "type": "string",
          "format": "uuid",
          "description": "The unique identifier for the course."
        },
        "name": {
          "type": "string",
          "description": "The course name or code."
        },
        "grade": {
          "type": "string",
          "description": "The grade earned for the course."
        },
        "description": {
          "type": "string",
          "description": "A description of the course."
        }
      }
    },
    "Subscription": {
      "type": "object",
      "additionalProperties": false,
      "required": ["status", "price_id"],
      "properties": {
        "status": {
          "type": "string",
          "description": "The current subscription status."
        },
        "price_id": {
          "type": "string",
          "description": "The payment provider price identifier associated with the subscription."
        }
      }
    }
  }
}

Rendering the Data

After fetching the data, your portfolio should map the response into your UI. You have full freedom to let your portfolio control the design. Nukleio simply supplies the content according to the schema above.

Integration Checklist

Before sharing the connected portfolio, confirm that:

the API key is valid
the request uses the Authorization bearer header
missing optional fields do not break the UI
project cards handle long descriptions or names
uploaded files and images load correctly
your portfolio handles API errors gracefully
updated Nukleio content appears after refresh, rebuild, or cache expiration