`
Get a JSON response with an array of data from all the models generated with the mesh generation system by the user.
Each element of the array follows the same format of a generated model as described in the endpoint `user-generated-model`
Within the JSON structure, At its raw level, you can find the mesh file in the formats cited above, e.g. `model.mesh.fbx` contains the FBX version of the generated model..
It's important to note that you have a free allowance of model processing credits which renews every month. Additional credits can be purchased in [your profile page](https://app.anything.world/profile).
#### Query Parameters
| Name | Type | Description |
| ------------------------------------- | ------ | ------------ |
| key\* | String | Your API key |
{% tabs %}
{% tab title="200: OK Generated models have been found" %}
```javascript
{
// Response
}
```
{% endtab %}
{% endtabs %}
### Example: generate and animate a 3D model
This example demonstrates how to use the `/text-to-3d` and `/animate` endpoints in sequence to generate a 3D model, poll for its status, and animate it once the model has been generated.
#### Prerequisites
* Node.js installed.
* `axios` for making HTTP requests (`npm install axios`).
* API credentials (API key).
#### Code Example
const axios = require('axios');
const FormData = require("form-data");
// Configuration
const API_BASE_URL = process.env.API_BASE_URL || "https://api.anything.world"; // Environment variable fallback
const API_KEY = process.env.API_KEY || "your-api-key";
const MAX_ATTEMPTS = 10;
const POLL_INTERVAL_MS = 2000;
// Constants
const STATUS_CODE_STILL_PROCESSING = 403;
const CODE_STILL_PROCESSING = "Still Processing";
// Function to generate a 3D model
async function generateModel(prompt, refinePrompt = true) {
try {
const response = await axios.post(`${API_BASE_URL}/text-to-3d`, {
text_prompt: prompt,
key: API_KEY,
refine_prompt: refinePrompt,
});
return response.data.model_id;
} catch (error) {
console.error("Error during model generation:", error.response?.data || error.message);
throw new Error("Failed to generate model.");
}
}
// Function to poll for status
async function pollStatus(endpoint, id, stage) {
let attempts = 0;
while (attempts < MAX_ATTEMPTS) {
try {
const url = new URL(`${API_BASE_URL}/${endpoint}`);
url.searchParams.append("key", API_KEY);
url.searchParams.append("id", id);
if (stage) {
url.searchParams.append("stage", stage);
}
const response = await axios.get(url.toString());
console.log(`Polling attempt ${attempts + 1}: Status =`, response.data);
return response.data; // Return data if the request succeeds
} catch (error) {
const statusCode = error.response?.status;
const errorCode = error.response?.data?.code;
if (statusCode === STATUS_CODE_STILL_PROCESSING && errorCode === CODE_STILL_PROCESSING) {
console.log(
`Polling attempt ${attempts + 1} for ID ${id}: Still Processing... Retrying in ${
POLL_INTERVAL_MS / 1000
} seconds.`
);
} else {
console.error(
`Polling attempt ${attempts + 1} failed for ID ${id}:`,
error.response?.data || error.message
);
if (attempts === MAX_ATTEMPTS - 1) {
throw new Error(`Polling for ${endpoint} (ID: ${id}) timed out or failed.`);
}
}
}
attempts++;
await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
}
throw new Error(`Polling for ${endpoint} (ID: ${id}) timed out.`);
}
// utility function to get file name from url
function getFileNameFromUrl(url) {
return url.substring(url.lastIndexOf('/') + 1, url.indexOf('?') !== -1 ? url.indexOf('?') : url.length);
}
// Download files from signed URLs and store as blob in memory
async function getFilesAndAppendToFormData(modelData) {
// Download files in memory using axios
const objFile = await axios.get(modelData['model'].mesh.obj, { responseType: 'blob' });
const mtlFile = await axios.get(modelData['model'].material, { responseType: 'blob' });
let textureFiles = [];
if (modelData['model'].textures && modelData['model'].textures.length > 0) {
// Download textures in memory using axios
textureFiles = await Promise.all(
modelData['model'].textures.map(async (textureUrl, index) => {
const response = await axios.get(textureUrl, { responseType: 'blob' });
// Extract the file name from the URL
const fileName = getFileNameFromUrl(textureUrl);
return new File([response.data], fileName);
})
);
}
const formData = new FormData();
formData.append('files', new File([objFile.data], getFileNameFromUrl(freshlyGeneratedModel.objUrl)));
formData.append('files', new File([mtlFile.data], getFileNameFromUrl(freshlyGeneratedModel.mtlUrl)));
if (textureFiles.length > 0) {
textureFiles.forEach(textureFile => formData.append('files', textureFile));
}
return formData;
}
// Function to animate a model
async function animateModel(modelData, modelName, modelType, options = {}) {
try {
const formData = getFilesAndAppendToFormData(modelData);
// Append required fields
formData.append("key", API_KEY);
formData.append("model_name", modelName);
formData.append("model_type", modelType);
// Append optional fields with defaults
formData.append("symmetry", options.symmetry || "false");
formData.append("auto_classify", options.auto_classify || "false");
formData.append("auto_rotate", options.auto_rotate || "false");
formData.append("can_use_for_internal_improvements", options.can_use_for_internal_improvements || "false");
formData.append("author", options.author || "");
formData.append("license", options.license || "ccby");
// Make the POST request to the animate endpoint
const response = await axios.post(`${API_BASE_URL}/animate`, formData, {
headers: {
...formData.getHeaders(),
},
});
console.log("Animation request successful:", response.data);
return response.data.model_id;
} catch (error) {
console.error("Error during animation:", error.response?.data || error.message);
throw new Error("Failed to animate model.");
}
}
// Main function to orchestrate the process
async function generateAndAnimateModel() {
try {
// Step 1: Generate a 3D model
const modelPrompt = "A blue cat"; // Customize your prompt here
const modelId = await generateModel(modelPrompt, true);
console.log(`Generated model ID: ${modelId}`);
// Step 2: Poll for the model's status
const modelData = await pollStatus("user-generated-model", modelId);
console.log("Model generation completed:", modelData);
// Step 3: Prepare the request to animate the model
const modelName = "A blue cat"; // Name your model
const modelType = "cat"; // Specify the model type
const animationOptions = {
symmetry: "true",
auto_classify: "false",
auto_rotate: "true",
can_use_for_internal_improvements: "true",
author: "John Doe",
license: "ccby",
};
// Step 4: Animate the model
const animatedModelId = await animateModel(modelData, modelName, modelType, animationOptions);
console.log(`Animated Model ID: ${animatedModelId}`);
// Step 5: Poll for the animated model status
const animationData = await pollStatus("user-processed-model", animatedModelId, 'done'); // mention stage param according to your usecase (More details in user-processed-model api section)
console.log("Animation completed:", animationData);
console.log("Process completed successfully!");
} catch (error) {
console.error("Error during the process:", error.message);
}
}
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://anything-world.gitbook.io/anything-world/api/rest-api-references.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.